@libp2p/interface-compliance-tests 1.1.28 → 1.1.31

package/src/pubsub/connection-handlers.ts

@@ -4,7 +4,6 @@ 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 { connectPeers } from '../mocks/registrar.js'
 import type { TestSetup } from '../index.js'
 import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
@@ -12,6 +11,7 @@ import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 import { createComponents } from './utils.js'
 import { pEvent } from 'p-event'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub connection handlers', () => {
@@ -23,27 +23,28 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
     describe('nodes send state on connection', () => {
       // Create pubsub nodes and connect them
       beforeEach(async () => {
+        mockNetwork.reset()
+
         componentsA = await createComponents()
         componentsB = await createComponents()
 
-        psA = await common.setup({
+        psA = componentsA.setPubSub(await common.setup({
           components: componentsA,
           init: {}
-        })
-        psB = await common.setup({
+        }))
+
+        psB = componentsB.setPubSub(await common.setup({
           components: componentsB,
           init: {}
-        })
+        }))
 
         // Start pubsub
-        await start(psA, psB)
+        await start(componentsA, componentsB)
 
         expect(psA.getPeers()).to.be.empty()
         expect(psB.getPeers()).to.be.empty()
-      })
 
-      // Make subscriptions prior to nodes connected
-      beforeEach(() => {
+        // Make subscriptions prior to nodes connected
         psA.subscribe('Za')
         psB.subscribe('Zb')
 
@@ -55,8 +56,9 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       afterEach(async () => {
         sinon.restore()
-        await stop(psA, psB)
+        await stop(componentsA, componentsB)
         await common.teardown()
+        mockNetwork.reset()
       })
 
       it('existing subscriptions are sent upon peer connection', async function () {
@@ -65,7 +67,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
           pEvent(psB, 'subscription-change')
         ])
 
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         await subscriptionsChanged
 
@@ -88,29 +90,31 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       // Create pubsub nodes and start them
       beforeEach(async () => {
+        mockNetwork.reset()
         componentsA = await createComponents()
         componentsB = await createComponents()
 
-        psA = await common.setup({
+        psA = componentsA.setPubSub(await common.setup({
           components: componentsA,
           init: {}
-        })
-        psB = await common.setup({
+        }))
+        psB = componentsB.setPubSub(await common.setup({
           components: componentsB,
           init: {}
-        })
+        }))
 
-        await start(psA, psB)
+        await start(componentsA, componentsB)
       })
 
       afterEach(async () => {
         sinon.restore()
-        await stop(psA, psB)
+        await stop(componentsA, componentsB)
         await common.teardown()
+        mockNetwork.reset()
       })
 
       it('should get notified of connected peers on dial', async () => {
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         return await Promise.all([
           pWaitFor(() => psA.getPeers().length === 1),
@@ -123,7 +127,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         const topic = 'test-topic'
         const data = uint8ArrayFromString('hey!')
 
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -160,29 +164,31 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       // Create pubsub nodes
       beforeEach(async () => {
+        mockNetwork.reset()
         componentsA = await createComponents()
         componentsB = await createComponents()
 
-        psA = await common.setup({
+        psA = componentsA.setPubSub(await common.setup({
           components: componentsA,
           init: {}
-        })
-        psB = await common.setup({
+        }))
+        psB = componentsB.setPubSub(await common.setup({
           components: componentsB,
           init: {}
-        })
+        }))
       })
 
       afterEach(async () => {
         sinon.restore()
-        await stop(psA, psB)
+        await stop(componentsA, componentsB)
         await common.teardown()
+        mockNetwork.reset()
       })
 
       it('should get notified of connected peers after starting', async () => {
-        await start(psA, psB)
+        await start(componentsA, componentsB)
 
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         return await Promise.all([
           pWaitFor(() => psA.getPeers().length === 1),
@@ -195,9 +201,9 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         const topic = 'test-topic'
         const data = uint8ArrayFromString('hey!')
 
-        await start(psA, psB)
+        await start(componentsA, componentsB)
 
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         await Promise.all([
           pWaitFor(() => psA.getPeers().length === 1),
@@ -239,25 +245,27 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       // Create pubsub nodes and start them
       beforeEach(async () => {
+        mockNetwork.reset()
         componentsA = await createComponents()
         componentsB = await createComponents()
 
-        psA = await common.setup({
+        psA = componentsA.setPubSub(await common.setup({
           components: componentsA,
           init: {}
-        })
-        psB = await common.setup({
+        }))
+        psB = componentsB.setPubSub(await common.setup({
           components: componentsB,
           init: {}
-        })
+        }))
 
-        await start(psA, psB)
+        await start(componentsA, componentsB)
       })
 
       afterEach(async () => {
         sinon.restore()
-        await stop(psA, psB)
+        await stop(componentsA, componentsB)
         await common.teardown()
+        mockNetwork.reset()
       })
 
       it.skip('should receive pubsub messages after a node restart', async function () {
@@ -268,7 +276,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         const defer1 = pDefer()
         const defer2 = pDefer()
 
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
@@ -296,9 +304,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
         await defer1.promise
 
-        await psB.stop()
-        // @ts-expect-error protected fields
-        await psB._libp2p.stop()
+        await stop(psB)
         await pWaitFor(() => {
           // @ts-expect-error protected fields
           const aHasConnectionToB = psA._libp2p.connectionManager.get(psB.peerId)
@@ -307,11 +313,9 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
           return aHasConnectionToB != null && bHasConnectionToA != null
         })
-        // @ts-expect-error protected fields
-        await psB._libp2p.start()
-        await psB.start()
+        await start(psB)
 
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         // wait for remoteLibp2p to know about libp2p subscription
         await pWaitFor(() => {
@@ -375,7 +379,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         const originalConnection = await psA._libp2p.dialer.connectToPeer(psB.peerId)
 
         // second connection
-        await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+        await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
         // Wait for subscriptions to occur
         await pWaitFor(() => {

package/src/pubsub/emit-self.ts

@@ -9,6 +9,7 @@ import { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
 import { createComponents } from './utils.js'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
@@ -16,30 +17,30 @@ const shouldNotHappen = () => expect.fail()
 
 export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('emit self', () => {
-    let pubsub: PubSub
-    let components: Components
-
     describe('enabled', () => {
+      let pubsub: PubSub
+      let components: Components
+
       before(async () => {
+        mockNetwork.reset()
         components = await createComponents()
 
-        pubsub = await common.setup({
+        pubsub = components.setPubSub(await common.setup({
           components,
           init: {
             emitSelf: true
           }
-        })
-      })
+        }))
 
-      before(async () => {
-        await start(pubsub)
+        await start(components)
         pubsub.subscribe(topic)
       })
 
       after(async () => {
         sinon.restore()
-        await stop(pubsub)
+        await stop(components)
         await common.teardown()
+        mockNetwork.reset()
       })
 
       it('should emit to self on publish', async () => {
@@ -62,27 +63,31 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
     })
 
     describe('disabled', () => {
+      let pubsub: PubSub
+      let components: Components
+
       before(async () => {
-        pubsub = await common.setup({
-          components: new Components({
-            peerId: await createEd25519PeerId(),
-            registrar: mockRegistrar()
-          }),
+        mockNetwork.reset()
+        components = new Components({
+          peerId: await createEd25519PeerId(),
+          registrar: mockRegistrar()
+        })
+        pubsub = components.setPubSub(await common.setup({
+          components,
           init: {
             emitSelf: false
           }
-        })
-      })
+        }))
 
-      before(async () => {
-        await start(pubsub)
+        await start(components)
         pubsub.subscribe(topic)
       })
 
       after(async () => {
         sinon.restore()
-        await stop(pubsub)
+        await stop(components)
         await common.teardown()
+        mockNetwork.reset()
       })
 
       it('should not emit to self on publish', async () => {

package/src/pubsub/messages.ts

@@ -8,6 +8,7 @@ import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 import { pEvent } from 'p-event'
 import { createComponents } from './utils.js'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
@@ -19,21 +20,23 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
     // Create pubsub router
     beforeEach(async () => {
+      mockNetwork.reset()
       components = await createComponents()
 
-      pubsub = await common.setup({
+      pubsub = components.setPubSub(await common.setup({
         components,
         init: {
           emitSelf: true
         }
-      })
-      await start(pubsub)
+      }))
+      await start(components)
     })
 
     afterEach(async () => {
       sinon.restore()
-      await stop(pubsub)
+      await stop(components)
       await common.teardown()
+      mockNetwork.reset()
     })
 
     it('should emit normalized signed messages on publish', async () => {

package/src/pubsub/multiple-nodes.ts

@@ -5,7 +5,6 @@ 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 { connectPeers } from '../mocks/registrar.js'
 import { createComponents, waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
 import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
@@ -13,6 +12,7 @@ import type { PubSubArgs } from './index.js'
 import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
 import delay from 'delay'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 export default (common: TestSetup<PubSub, PubSubArgs>) => {
   describe('pubsub with multiple nodes', function () {
@@ -30,37 +30,37 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
         // Create and start pubsub nodes
         beforeEach(async () => {
+          mockNetwork.reset()
+
           componentsA = await createComponents()
           componentsB = await createComponents()
           componentsC = await createComponents()
 
-          psA = await common.setup({
+          psA = componentsA.setPubSub(await common.setup({
             components: componentsA,
             init: {
               emitSelf: true
             }
-          })
-          psB = await common.setup({
+          }))
+          psB = componentsB.setPubSub(await common.setup({
             components: componentsB,
             init: {
               emitSelf: true
             }
-          })
-          psC = await common.setup({
+          }))
+          psC = componentsC.setPubSub(await common.setup({
             components: componentsC,
             init: {
               emitSelf: true
             }
-          })
+          }))
 
           // Start pubsub modes
-          await start(psA, psB, psC)
-        })
+          await start(componentsA, componentsB, componentsC)
 
-        // Connect nodes
-        beforeEach(async () => {
-          await connectPeers(psA.multicodecs[0], componentsA, componentsB)
-          await connectPeers(psB.multicodecs[0], componentsB, componentsC)
+          // Connect nodes
+          await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
+          await componentsB.getConnectionManager().openConnection(componentsC.getPeerId())
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
@@ -72,10 +72,9 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
         afterEach(async () => {
           sinon.restore()
-
-          await stop(psA, psB, psC)
-
+          await stop(componentsA, componentsB, componentsC)
           await common.teardown()
+          mockNetwork.reset()
         })
 
         it('subscribe to the topic on node a', async () => {
@@ -259,53 +258,53 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
         // Create and start pubsub nodes
         beforeEach(async () => {
+          mockNetwork.reset()
+
           componentsA = await createComponents()
           componentsB = await createComponents()
           componentsC = await createComponents()
           componentsD = await createComponents()
           componentsE = await createComponents()
 
-          psA = await common.setup({
+          psA = componentsA.setPubSub(await common.setup({
             components: componentsA,
             init: {
               emitSelf: true
             }
-          })
-          psB = await common.setup({
+          }))
+          psB = componentsB.setPubSub(await common.setup({
             components: componentsB,
             init: {
               emitSelf: true
             }
-          })
-          psC = await common.setup({
+          }))
+          psC = componentsC.setPubSub(await common.setup({
             components: componentsC,
             init: {
               emitSelf: true
             }
-          })
-          psD = await common.setup({
+          }))
+          psD = componentsD.setPubSub(await common.setup({
             components: componentsD,
             init: {
               emitSelf: true
             }
-          })
-          psE = await common.setup({
+          }))
+          psE = componentsE.setPubSub(await common.setup({
             components: componentsE,
             init: {
               emitSelf: true
             }
-          })
+          }))
 
           // Start pubsub nodes
-          await start(psA, psB, psC, psD, psE)
-        })
+          await start(componentsA, componentsB, componentsC, componentsD, componentsE)
 
-        // connect nodes
-        beforeEach(async () => {
-          await connectPeers(psA.multicodecs[0], componentsA, componentsB)
-          await connectPeers(psA.multicodecs[0], componentsB, componentsC)
-          await connectPeers(psA.multicodecs[0], componentsC, componentsD)
-          await connectPeers(psA.multicodecs[0], componentsD, componentsE)
+          // connect nodes
+          await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
+          await componentsB.getConnectionManager().openConnection(componentsC.getPeerId())
+          await componentsC.getConnectionManager().openConnection(componentsD.getPeerId())
+          await componentsD.getConnectionManager().openConnection(componentsE.getPeerId())
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
@@ -318,8 +317,9 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         })
 
         afterEach(async () => {
-          await stop(psA, psB, psC, psD, psE)
+          await stop(componentsA, componentsB, componentsC, componentsD, componentsE)
           await common.teardown()
+          mockNetwork.reset()
         })
 
         it('subscribes', () => {

package/src/pubsub/two-nodes.ts

@@ -5,13 +5,13 @@ 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 { connectPeers } from '../mocks/registrar.js'
 import { createComponents, waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
 import type { Message, PubSub } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
 import type { Components } from '@libp2p/interfaces/components'
 import { start, stop } from '../index.js'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 const topic = 'foo'
 
@@ -28,29 +28,31 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
     // Create pubsub nodes and connect them
     beforeEach(async () => {
+      mockNetwork.reset()
+
       componentsA = await createComponents()
       componentsB = await createComponents()
 
-      psA = await common.setup({
+      psA = componentsA.setPubSub(await common.setup({
         components: componentsA,
         init: {
           emitSelf: true
         }
-      })
-      psB = await common.setup({
+      }))
+      psB = componentsB.setPubSub(await common.setup({
         components: componentsB,
         init: {
           emitSelf: false
         }
-      })
+      }))
 
       // Start pubsub and connect nodes
-      await start(psA, psB)
+      await start(componentsA, componentsB)
 
       expect(psA.getPeers()).to.be.empty()
       expect(psB.getPeers()).to.be.empty()
 
-      await connectPeers(psA.multicodecs[0], componentsA, componentsB)
+      await componentsA.getConnectionManager().openConnection(componentsB.getPeerId())
 
       // Wait for peers to be ready in pubsub
       await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
@@ -58,10 +60,9 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
     afterEach(async () => {
       sinon.restore()
-
-      await stop(psA, psB)
-
+      await stop(componentsA, componentsB)
       await common.teardown()
+      mockNetwork.reset()
     })
 
     it('Subscribe to a topic in nodeA', async () => {

package/src/pubsub/utils.ts

@@ -5,6 +5,7 @@ import type { PubSub, SubscriptionChangeData } from '@libp2p/interfaces/pubsub'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { mockConnectionManager, mockRegistrar } from '../mocks/index.js'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId) {
   await pWaitFor(async () => {
@@ -15,9 +16,13 @@ export async function waitForSubscriptionUpdate (a: PubSub, b: PeerId) {
 }
 
 export async function createComponents (): Promise<Components> {
-  return new Components({
+  const components = new Components({
     peerId: await createEd25519PeerId(),
     registrar: mockRegistrar(),
     connectionManager: mockConnectionManager()
   })
+
+  mockNetwork.addNode(components)
+
+  return components
 }