@libp2p/interface-compliance-tests 1.1.29 → 1.1.30

package/src/mocks/connection-manager.ts

@@ -1,23 +1,137 @@
-import { EventEmitter } from '@libp2p/interfaces'
+import { CustomEvent, EventEmitter, Startable } from '@libp2p/interfaces'
 import type { Connection } from '@libp2p/interfaces/connection'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/registrar'
+import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interfaces/connection-manager'
+import type { Components, Initializable } from '@libp2p/interfaces/src/components'
+import { connectionPair } from './connection.js'
+import errCode from 'err-code'
 
-class MockConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager {
-  getConnectionMap (): Map<string, Connection[]> {
-    return new Map<string, Connection[]>()
+class MockNetwork {
+  private components: Components[] = []
+
+  addNode (components: Components): void {
+    this.components.push(components)
+  }
+
+  getNode (peerId: PeerId): Components {
+    for (const components of this.components) {
+      if (peerId.equals(components.getPeerId())) {
+        return components
+      }
+    }
+
+    throw errCode(new Error('Peer not found'), 'ERR_PEER_NOT_FOUND')
+  }
+
+  reset () {
+    this.components = []
+  }
+}
+
+export const mockNetwork = new MockNetwork()
+
+class MockConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Initializable, Startable {
+  private connections: Connection[] = []
+  private components?: Components
+  private started = false
+
+  init (components: Components) {
+    this.components = components
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  async start () {
+    this.started = true
+  }
+
+  async stop () {
+    for (const connection of this.connections) {
+      await this.closeConnections(connection.remotePeer)
+    }
+
+    this.started = false
   }
 
-  getConnectionList (): Connection[] {
-    return []
+  getConnections (peerId?: PeerId): Connection[] {
+    if (peerId != null) {
+      return this.connections
+        .filter(c => c.remotePeer.toString() === peerId.toString())
+    }
+
+    return this.connections
   }
 
-  getConnections (): Connection[] {
-    return []
+  async openConnection (peerId: PeerId) {
+    if (this.components == null) {
+      throw errCode(new Error('Not initialized'), 'ERR_NOT_INITIALIZED')
+    }
+
+    const existingConnections = this.getConnections(peerId)
+
+    if (existingConnections.length > 0) {
+      return existingConnections[0]
+    }
+
+    const componentsB = mockNetwork.getNode(peerId)
+
+    const [aToB, bToA] = connectionPair(this.components, componentsB)
+
+    // track connections
+    this.connections.push(aToB)
+    ;(componentsB.getConnectionManager() as MockConnectionManager).connections.push(bToA)
+
+    this.components.getConnectionManager().dispatchEvent(new CustomEvent<Connection>('peer:connect', {
+      detail: aToB
+    }))
+
+    for (const protocol of this.components.getRegistrar().getProtocols()) {
+      for (const topology of this.components.getRegistrar().getTopologies(protocol)) {
+        topology.onConnect(componentsB.getPeerId(), aToB)
+      }
+    }
+
+    componentsB.getConnectionManager().dispatchEvent(new CustomEvent<Connection>('peer:connect', {
+      detail: bToA
+    }))
+
+    for (const protocol of componentsB.getRegistrar().getProtocols()) {
+      for (const topology of componentsB.getRegistrar().getTopologies(protocol)) {
+        topology.onConnect(this.components.getPeerId(), bToA)
+      }
+    }
+
+    return aToB
   }
 
-  getConnection (peerId: PeerId): Connection | undefined {
-    return undefined
+  async closeConnections (peerId: PeerId) {
+    if (this.components == null) {
+      throw errCode(new Error('Not initialized'), 'ERR_NOT_INITIALIZED')
+    }
+
+    const connections = this.getConnections(peerId)
+
+    if (connections.length === 0) {
+      return
+    }
+
+    const componentsB = mockNetwork.getNode(peerId)
+
+    for (const protocol of this.components.getRegistrar().getProtocols()) {
+      this.components.getRegistrar().getTopologies(protocol).forEach(topology => {
+        topology.onDisconnect(componentsB.getPeerId())
+      })
+    }
+
+    for (const conn of connections) {
+      await conn.close()
+    }
+
+    this.connections = this.connections.filter(c => !c.remotePeer.equals(peerId))
+
+    await componentsB.getConnectionManager().closeConnections(peerId)
   }
 }
 

package/src/mocks/index.ts

@@ -1,6 +1,6 @@
 
 export { mockConnectionGater } from './connection-gater.js'
-export { mockConnectionManager } from './connection-manager.js'
+export { mockConnectionManager, mockNetwork } from './connection-manager.js'
 export { mockConnection, mockStream, connectionPair } from './connection.js'
 export { mockMultiaddrConnection, mockMultiaddrConnPair } from './multiaddr-connection.js'
 export { mockMuxer } from './muxer.js'

package/src/mocks/registrar.ts

@@ -2,8 +2,6 @@ import type { IncomingStreamData, Registrar, StreamHandler } from '@libp2p/inter
 import type { Connection } from '@libp2p/interfaces/connection'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Topology } from '@libp2p/interfaces/topology'
-import { connectionPair } from './connection.js'
-import type { Components } from '@libp2p/interfaces/src/components'
 
 export class MockRegistrar implements Registrar {
   private readonly topologies: Map<string, { topology: Topology, protocols: string[] }> = new Map()
@@ -89,7 +87,7 @@ export class MockRegistrar implements Registrar {
       return output
     }
 
-    throw new Error(`No topologies registered for protocol ${protocol}`)
+    return []
   }
 }
 
@@ -106,16 +104,3 @@ export async function mockIncomingStreamEvent (protocol: string, conn: Connectio
     }
   }
 }
-
-export async function connectPeers (protocol: string, a: Components, b: Components) {
-  // Notify peers of connection
-  const [aToB, bToA] = connectionPair(a, b)
-
-  for (const topology of a.getRegistrar().getTopologies(protocol)) {
-    await topology.onConnect(b.getPeerId(), aToB)
-  }
-
-  for (const topology of b.getRegistrar().getTopologies(protocol)) {
-    await topology.onConnect(a.getPeerId(), bToA)
-  }
-}

package/src/pubsub/api.ts

@@ -11,6 +11,7 @@ import type { Components } from '@libp2p/interfaces/components'
 import { createComponents } from './utils.js'
 import { start, stop } from '../index.js'
 import { isStartable } from '@libp2p/interfaces'
+import { mockNetwork } from '../mocks/connection-manager.js'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
@@ -22,20 +23,22 @@ 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
         }
-      })
+      }))
     })
 
     afterEach(async () => {
       sinon.restore()
-      await stop(pubsub)
+      await stop(common)
       await common.teardown()
+      mockNetwork.reset()
     })
 
     it('can start correctly', async () => {
@@ -45,7 +48,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       sinon.spy(components.getRegistrar(), 'register')
 
-      await pubsub.start()
+      await start(components)
 
       expect(pubsub.isStarted()).to.equal(true)
       expect(components.getRegistrar().register).to.have.property('callCount', 1)
@@ -58,8 +61,8 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
 
       sinon.spy(components.getRegistrar(), 'unregister')
 
-      await pubsub.start()
-      await pubsub.stop()
+      await start(components)
+      await stop(components)
 
       expect(pubsub.isStarted()).to.equal(false)
       expect(components.getRegistrar().unregister).to.have.property('callCount', 1)
@@ -70,7 +73,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         throw new Error('a message should not be received')
       }
 
-      await start(pubsub)
+      await start(components)
       pubsub.subscribe(topic)
       pubsub.addEventListener('message', handler)
 
@@ -90,13 +93,13 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
       // handlers are called async
       await delay(100)
 
-      await stop(pubsub)
+      await stop(components)
     })
 
     it('can subscribe and publish correctly', async () => {
       const defer = pDefer()
 
-      await start(pubsub)
+      await start(components)
 
       pubsub.subscribe(topic)
       pubsub.addEventListener('message', (evt) => {
@@ -107,7 +110,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
       await pubsub.publish(topic, data)
       await defer.promise
 
-      await stop(pubsub)
+      await stop(components)
     })
   })
 }

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)
@@ -307,7 +315,7 @@ export default (common: TestSetup<PubSub, PubSubArgs>) => {
         })
         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(() => {
@@ -371,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 () => {