@libp2p/interface-compliance-tests 1.0.6 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "description": "Compliance tests for JS libp2p interfaces",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/libp2p-interface-compliance-tests#readme",
@@ -73,8 +73,12 @@
       "types": "./dist/src/stream-muxer/index.d.ts"
     },
     "./topology": {
-      "import": "./dist/src/topology/index.js",
-      "types": "./dist/src/topology/index.d.ts"
+      "import": "./dist/src/topology/topology.js",
+      "types": "./dist/src/topology/topology.d.ts"
+    },
+    "./topology/multicodec-toplogy": {
+      "import": "./dist/src/topology/multicodec-toplogy.js",
+      "types": "./dist/src/topology/multicodec-toplogy.d.ts"
     },
     "./transport": {
       "import": "./dist/src/transport/index.js",
@@ -84,6 +88,38 @@
       "import": "./dist/src/transport/utils/index.js",
       "types": "./dist/src/transport/utils/index.d.ts"
     },
+    "./utils/mock-connection": {
+      "import": "./dist/src/utils/mock-connection.js",
+      "types": "./dist/src/utils/mock-connection.d.ts"
+    },
+    "./utils/mock-connection-gater": {
+      "import": "./dist/src/utils/mock-connection-gater.js",
+      "types": "./dist/src/utils/mock-connection-gater.d.ts"
+    },
+    "./utils/mock-connection-manager": {
+      "import": "./dist/src/utils/mock-connection-manager.js",
+      "types": "./dist/src/utils/mock-connection-manager.d.ts"
+    },
+    "./utils/mock-multiaddr-connection": {
+      "import": "./dist/src/utils/mock-multiaddr-connection.js",
+      "types": "./dist/src/utils/mock-multiaddr-connection.d.ts"
+    },
+    "./utils/mock-muxer": {
+      "import": "./dist/src/utils/mock-muxer.js",
+      "types": "./dist/src/utils/mock-muxer.d.ts"
+    },
+    "./utils/mock-peer-store": {
+      "import": "./dist/src/utils/mock-peer-store.js",
+      "types": "./dist/src/utils/mock-peer-store.d.ts"
+    },
+    "./utils/mock-registrar": {
+      "import": "./dist/src/utils/mock-registrar.js",
+      "types": "./dist/src/utils/mock-registrar.d.ts"
+    },
+    "./utils/mock-upgrader": {
+      "import": "./dist/src/utils/mock-upgrader.js",
+      "types": "./dist/src/utils/mock-upgrader.d.ts"
+    },
     "./utils/peers": {
       "import": "./dist/src/utils/peers.js",
       "types": "./dist/src/utils/peers.d.ts"
@@ -178,10 +214,10 @@
   },
   "scripts": {
     "lint": "aegir lint",
-    "dep-check": "aegir dep-check dist/src/**/*.js",
+    "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js",
     "build": "tsc",
     "pretest": "npm run build",
-    "test": "aegir test -f ./dist/test/**/*.js",
+    "test": "aegir test -f ./dist/test/*.js -f ./dist/test/**/*.js",
     "test:chrome": "npm run test -- -t browser",
     "test:chrome-webworker": "npm run test -- -t webworker",
     "test:firefox": "npm run test -- -t browser -- --browser firefox",
@@ -190,13 +226,11 @@
     "test:electron-main": "npm run test -- -t electron-main"
   },
   "dependencies": {
-    "@libp2p/connection": "^1.0.0",
     "@libp2p/crypto": "^0.22.2",
     "@libp2p/interfaces": "^1.0.0",
     "@libp2p/peer-id": "^1.0.0",
     "@libp2p/peer-id-factory": "^1.0.0",
-    "@libp2p/pubsub": "^1.0.0",
-    "@libp2p/topology": "^1.0.0",
+    "@libp2p/pubsub": "^1.1.0",
     "@multiformats/multiaddr": "^10.1.1",
     "abortable-iterator": "^4.0.0",
     "aegir": "^36.1.3",
@@ -207,11 +241,12 @@
     "it-map": "^1.0.6",
     "it-pair": "^2.0.0",
     "it-pipe": "^2.0.2",
+    "it-pushable": "^2.0.1",
     "multiformats": "^9.4.10",
     "p-defer": "^4.0.0",
     "p-limit": "^4.0.0",
     "p-wait-for": "^4.1.0",
-    "sinon": "^12.0.1",
+    "sinon": "^13.0.0",
     "uint8arrays": "^3.0.0",
     "util": "^0.12.4"
   },

package/src/peer-discovery/index.ts

@@ -16,9 +16,6 @@ export default (common: TestSetup<PeerDiscovery & Startable>) => {
 
     afterEach('ensure discovery was stopped', async () => {
       await discovery.stop()
-
-      discovery.removeAllListeners()
-
       await common.teardown()
     })
 
@@ -44,7 +41,8 @@ export default (common: TestSetup<PeerDiscovery & Startable>) => {
       const defer = pDefer()
       await discovery.start()
 
-      discovery.on('peer', ({ id, multiaddrs }) => {
+      discovery.addEventListener('peer', (evt) => {
+        const { id, multiaddrs } = evt.detail
         expect(id).to.exist()
         expect(id).to.have.property('type').that.is.oneOf(['RSA', 'Ed25519', 'secp256k1'])
         expect(multiaddrs).to.exist()
@@ -58,7 +56,7 @@ export default (common: TestSetup<PeerDiscovery & Startable>) => {
     })
 
     it('should not receive a peer event before start', async () => {
-      discovery.on('peer', () => {
+      discovery.addEventListener('peer', () => {
         throw new Error('should not receive a peer event before start')
       })
 
@@ -70,14 +68,14 @@ export default (common: TestSetup<PeerDiscovery & Startable>) => {
 
       await discovery.start()
 
-      discovery.on('peer', () => {
+      discovery.addEventListener('peer', () => {
         deferStart.resolve()
       })
 
       await deferStart.promise
       await discovery.stop()
 
-      discovery.on('peer', () => {
+      discovery.addEventListener('peer', () => {
         throw new Error('should not receive a peer event after stop')
       })
 

package/src/pubsub/api.ts

@@ -4,15 +4,15 @@ 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, Message } from '@libp2p/interfaces/pubsub'
-import type { Startable } from '@libp2p/interfaces'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('pubsub api', () => {
-    let pubsub: PubSub & Startable
+    let pubsub: PubSub<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {
@@ -51,7 +51,7 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
       await pubsub.start()
       pubsub.subscribe(topic)
-      pubsub.on('topic', handler)
+      pubsub.addEventListener('topic', handler)
 
       await pWaitFor(() => {
         const topics = pubsub.getTopics()
@@ -71,15 +71,14 @@ export default (common: TestSetup<PubSub & Startable>) => {
     it('can subscribe and publish correctly', async () => {
       const defer = pDefer()
 
-      const handler = (msg: Message) => {
-        expect(msg).to.not.eql(undefined)
-        defer.resolve()
-      }
-
       await pubsub.start()
 
       pubsub.subscribe(topic)
-      pubsub.on(topic, handler)
+      pubsub.addEventListener(topic, (evt) => {
+        const msg = evt.detail
+        expect(msg).to.not.eql(undefined)
+        defer.resolve()
+      })
       await pubsub.publish(topic, data)
       await defer.promise
 

package/src/pubsub/connection-handlers.ts

@@ -7,12 +7,12 @@ 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 { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('pubsub connection handlers', () => {
-    let psA: PubSub & Startable
-    let psB: PubSub & Startable
+    let psA: PubSub<EventMap>
+    let psB: PubSub<EventMap>
 
     describe('nodes send state on connection', () => {
       // Create pubsub nodes and connect them
@@ -48,8 +48,12 @@ export default (common: TestSetup<PubSub & Startable>) => {
         await Promise.all([
           // @ts-expect-error protected fields
           psA._libp2p.dial(psB.peerId),
-          new Promise((resolve) => psA.once('pubsub:subscription-change', resolve)),
-          new Promise((resolve) => psB.once('pubsub:subscription-change', resolve))
+          new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
+            once: true
+          })),
+          new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
+            once: true
+          }))
         ])
 
         expect(psA.peers.size).to.equal(1)
@@ -103,7 +107,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.on(topic, (msg) => {
+        psA.addEventListener(topic, (evt) => {
+          const msg = evt.detail
           expect(msg.data).to.equalBytes(data)
           defer.resolve()
         })
@@ -174,7 +179,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.on(topic, (msg) => {
+        psA.addEventListener(topic, (evt) => {
+          const msg = evt.detail
           expect(msg.data).to.equalBytes(data)
           defer.resolve()
         })
@@ -228,7 +234,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.on(topic, (msg) => {
+        psA.addEventListener(topic, (evt) => {
+          const msg = evt.detail
           expect(msg.data).to.equalBytes(data)
           counter++
           counter === 1 ? defer1.resolve() : defer2.resolve()
@@ -285,7 +292,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
         let bReceivedFirstMessageFromA = false
         let bReceivedSecondMessageFromA = false
 
-        const handlerSpyA = (message: Message) => {
+        const handlerSpyA = (evt: CustomEvent<Message>) => {
+          const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
           if (data === 'message-from-b-1') {
@@ -296,7 +304,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
             aReceivedSecondMessageFromB = true
           }
         }
-        const handlerSpyB = (message: Message) => {
+        const handlerSpyB = (evt: CustomEvent<Message>) => {
+          const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
           if (data === 'message-from-a-1') {
@@ -310,8 +319,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
         const topic = 'reconnect-channel'
 
-        psA.on(topic, handlerSpyA)
-        psB.on(topic, handlerSpyB)
+        psA.addEventListener(topic, handlerSpyA)
+        psB.addEventListener(topic, handlerSpyB)
         psA.subscribe(topic)
         psB.subscribe(topic)
 

package/src/pubsub/emit-self.ts

@@ -3,15 +3,15 @@ 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 { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubSub & Startable, Partial<PubsubOptions>>) => {
+export default (common: TestSetup<PubSub<EventMap>, Partial<PubsubOptions>>) => {
   describe('emit self', () => {
-    let pubsub: PubSub & Startable
+    let pubsub: PubSub<EventMap>
 
     describe('enabled', () => {
       before(async () => {
@@ -30,7 +30,9 @@ export default (common: TestSetup<PubSub & Startable, Partial<PubsubOptions>>) =
       })
 
       it('should emit to self on publish', async () => {
-        const promise = new Promise((resolve) => pubsub.once(topic, resolve))
+        const promise = new Promise((resolve) => pubsub.addEventListener(topic, resolve, {
+          once: true
+        }))
 
         void pubsub.publish(topic, data)
 
@@ -55,7 +57,9 @@ export default (common: TestSetup<PubSub & Startable, Partial<PubsubOptions>>) =
       })
 
       it('should not emit to self on publish', async () => {
-        pubsub.once(topic, () => shouldNotHappen)
+        pubsub.addEventListener(topic, () => shouldNotHappen, {
+          once: true
+        })
 
         void pubsub.publish(topic, data)
 

package/src/pubsub/index.ts

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

package/src/pubsub/messages.ts

@@ -6,14 +6,14 @@ import * as utils from '@libp2p/pubsub/utils'
 import { PeerStreams } from '@libp2p/pubsub/peer-streams'
 import type { TestSetup } from '../index.js'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
-import type { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('messages', () => {
-    let pubsub: PubSub & Startable
+    let pubsub: PubSub<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {

package/src/pubsub/multiple-nodes.ts

@@ -9,18 +9,18 @@ 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 { Startable } from '@libp2p/interfaces'
+import type { EventMap } from './index.js'
 
-export default (common: TestSetup<PubSub & Startable>) => {
+export default (common: TestSetup<PubSub<EventMap>>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubSub & Startable
-        let psB: PubSub & Startable
-        let psC: PubSub & Startable
+        let psA: PubSub<EventMap>
+        let psB: PubSub<EventMap>
+        let psC: PubSub<EventMap>
 
         // Create and start pubsub nodes
         beforeEach(async () => {
@@ -60,7 +60,9 @@ export default (common: TestSetup<PubSub & Startable>) => {
           psA.subscribe(topic)
           expectSet(psA.subscriptions, [topic])
 
-          await new Promise((resolve) => psB.once('pubsub:subscription-change', resolve))
+          await new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
+            once: true
+          }))
           expect(psB.peers.size).to.equal(2)
 
           const aPeerId = psA.peerId.toString()
@@ -76,8 +78,12 @@ export default (common: TestSetup<PubSub & Startable>) => {
           expectSet(psB.subscriptions, [topic])
 
           await Promise.all([
-            new Promise((resolve) => psA.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psC.once('pubsub:subscription-change', resolve))
+            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
+              once: true
+            })),
+            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve, {
+              once: true
+            }))
           ])
 
           expect(psA.peers.size).to.equal(1)
@@ -94,12 +100,14 @@ export default (common: TestSetup<PubSub & Startable>) => {
           psC.subscribe(topic)
           expectSet(psC.subscriptions, [topic])
 
-          psB.once('pubsub:subscription-change', () => {
+          psB.addEventListener('pubsub:subscription-change', () => {
             expect(psA.peers.size).to.equal(1)
             expect(psB.peers.size).to.equal(2)
             expectSet(psB.topics.get(topic), [psC.peerId.toString()])
 
             defer.resolve()
+          }, {
+            once: true
           })
 
           return await defer.promise
@@ -115,9 +123,15 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
           // await subscription change
           await Promise.all([
-            new Promise(resolve => psA.once('pubsub:subscription-change', () => resolve(null))),
-            new Promise(resolve => psB.once('pubsub:subscription-change', () => resolve(null))),
-            new Promise(resolve => psC.once('pubsub:subscription-change', () => resolve(null)))
+            new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
+              once: true
+            })),
+            new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
+              once: true
+            })),
+            new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
+              once: true
+            }))
           ])
 
           // await a cycle
@@ -125,22 +139,23 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
           let counter = 0
 
-          psA.on(topic, incMsg)
-          psB.on(topic, incMsg)
-          psC.on(topic, incMsg)
+          psA.addEventListener(topic, incMsg)
+          psB.addEventListener(topic, incMsg)
+          psC.addEventListener(topic, incMsg)
 
           void psA.publish(topic, uint8ArrayFromString('hey'))
 
-          function incMsg (msg: Message) {
+          function incMsg (evt: CustomEvent<Message>) {
+            const msg = evt.detail
             expect(uint8ArrayToString(msg.data)).to.equal('hey')
             check()
           }
 
           function check () {
             if (++counter === 3) {
-              psA.removeListener(topic, incMsg)
-              psB.removeListener(topic, incMsg)
-              psC.removeListener(topic, incMsg)
+              psA.removeEventListener(topic, incMsg)
+              psB.removeEventListener(topic, incMsg)
+              psC.removeEventListener(topic, incMsg)
               defer.resolve()
             }
           }
@@ -168,30 +183,37 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
             // await subscription change
             await Promise.all([
-              new Promise(resolve => psA.once('pubsub:subscription-change', () => resolve(null))),
-              new Promise(resolve => psB.once('pubsub:subscription-change', () => resolve(null))),
-              new Promise(resolve => psC.once('pubsub:subscription-change', () => resolve(null)))
+              new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
+                once: true
+              })),
+              new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
+                once: true
+              })),
+              new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
+                once: true
+              }))
             ])
 
-            psA.on(topic, incMsg)
-            psB.on(topic, incMsg)
-            psC.on(topic, incMsg)
+            psA.addEventListener(topic, incMsg)
+            psB.addEventListener(topic, incMsg)
+            psC.addEventListener(topic, incMsg)
 
             // await a cycle
             await delay(1000)
 
             void psB.publish(topic, uint8ArrayFromString('hey'))
 
-            function incMsg (msg: Message) {
+            function incMsg (evt: CustomEvent<Message>) {
+              const msg = evt.detail
               expect(uint8ArrayToString(msg.data)).to.equal('hey')
               check()
             }
 
             function check () {
               if (++counter === 3) {
-                psA.removeListener(topic, incMsg)
-                psB.removeListener(topic, incMsg)
-                psC.removeListener(topic, incMsg)
+                psA.removeEventListener(topic, incMsg)
+                psB.removeEventListener(topic, incMsg)
+                psC.removeEventListener(topic, incMsg)
                 defer.resolve()
               }
             }
@@ -209,11 +231,11 @@ export default (common: TestSetup<PubSub & Startable>) => {
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubSub & Startable
-        let psB: PubSub & Startable
-        let psC: PubSub & Startable
-        let psD: PubSub & Startable
-        let psE: PubSub & Startable
+        let psA: PubSub<EventMap>
+        let psB: PubSub<EventMap>
+        let psC: PubSub<EventMap>
+        let psD: PubSub<EventMap>
+        let psE: PubSub<EventMap>
 
         // Create and start pubsub nodes
         beforeEach(async () => {
@@ -271,22 +293,22 @@ export default (common: TestSetup<PubSub & Startable>) => {
           let counter = 0
 
           psA.subscribe('Z')
-          psA.on('Z', incMsg)
+          psA.addEventListener('Z', incMsg)
           psB.subscribe('Z')
-          psB.on('Z', incMsg)
+          psB.addEventListener('Z', incMsg)
           psC.subscribe('Z')
-          psC.on('Z', incMsg)
+          psC.addEventListener('Z', incMsg)
           psD.subscribe('Z')
-          psD.on('Z', incMsg)
+          psD.addEventListener('Z', incMsg)
           psE.subscribe('Z')
-          psE.on('Z', incMsg)
+          psE.addEventListener('Z', incMsg)
 
           await Promise.all([
-            new Promise((resolve) => psA.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psB.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psC.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psD.once('pubsub:subscription-change', resolve)),
-            new Promise((resolve) => psE.once('pubsub:subscription-change', resolve))
+            new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psC.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psD.addEventListener('pubsub:subscription-change', resolve)),
+            new Promise((resolve) => psE.addEventListener('pubsub:subscription-change', resolve))
           ])
 
           // await a cycle
@@ -294,7 +316,8 @@ export default (common: TestSetup<PubSub & Startable>) => {
 
           void psC.publish('Z', uint8ArrayFromString('hey from c'))
 
-          function incMsg (msg: Message) {
+          function incMsg (evt: CustomEvent<Message>) {
+            const msg = evt.detail
             expect(uint8ArrayToString(msg.data)).to.equal('hey from c')
             check()
           }