@libp2p/interop 7.0.1 → 7.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interop",
-  "version": "7.0.1",
+  "version": "7.0.2",
   "description": "Interoperability Tests for libp2p",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/interop#readme",
@@ -128,7 +128,7 @@
     "clean": "aegir clean",
     "lint": "aegir lint",
     "dep-check": "aegir dep-check -i protons",
-    "build": "aegir build",
+    "build": "aegir build --bundle false",
     "postbuild": "cp src/resources/keys/*.key dist/src/resources/keys",
     "release": "aegir release"
   },

package/src/connect.ts

@@ -22,52 +22,51 @@ export function connectTests (factory: DaemonFactory): void {
 
 function runConnectTests (name: string, factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe(`connect using ${name}`, () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
     })
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       this.timeout(10 * 1000)
 
-      const identify1 = await daemons[0].client.identify()
-      const identify2 = await daemons[1].client.identify()
+      const identify1 = await daemonA.client.identify()
+      const identify2 = await daemonB.client.identify()
 
       // verify connected peers
-      const knownPeersBeforeConnect1 = await daemons[0].client.listPeers()
+      const knownPeersBeforeConnect1 = await daemonA.client.listPeers()
       expect(knownPeersBeforeConnect1).to.have.lengthOf(0)
 
-      const knownPeersBeforeConnect2 = await daemons[1].client.listPeers()
+      const knownPeersBeforeConnect2 = await daemonB.client.listPeers()
       expect(knownPeersBeforeConnect2).to.have.lengthOf(0)
 
       // connect peers
-      await daemons[0].client.connect(identify2.peerId, identify2.addrs)
+      await daemonA.client.connect(identify2.peerId, identify2.addrs)
 
-      // daemons[0] will take some time to get the peers
+      // daemonA will take some time to get the peers
       await new Promise(resolve => setTimeout(resolve, 1000))
 
       // verify connected peers
-      const knownPeersAfterConnect1 = await daemons[0].client.listPeers()
+      const knownPeersAfterConnect1 = await daemonA.client.listPeers()
       expect(knownPeersAfterConnect1).to.have.length.greaterThanOrEqual(1)
       expect(knownPeersAfterConnect1[0].toString()).to.equal(identify2.peerId.toString())
 
-      const knownPeersAfterConnect2 = await daemons[1].client.listPeers()
+      const knownPeersAfterConnect2 = await daemonB.client.listPeers()
       expect(knownPeersAfterConnect2).to.have.length.greaterThanOrEqual(1)
       expect(knownPeersAfterConnect2[0].toString()).to.equal(identify1.peerId.toString())
     })

package/src/dht/content-fetching.ts

@@ -29,21 +29,20 @@ export function contentFetchingTests (factory: DaemonFactory): void {
 
 function runContentFetchingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('dht.contentFetching', () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
 
       // connect them
-      const identify0 = await daemons[0].client.identify()
+      const identify0 = await daemonA.client.identify()
 
-      await daemons[1].client.connect(identify0.peerId, identify0.addrs)
+      await daemonB.client.connect(identify0.peerId, identify0.addrs)
 
       // jsDaemon1 will take some time to get the peers
       await new Promise(resolve => setTimeout(resolve, 1000))
@@ -51,19 +50,19 @@ function runContentFetchingTests (factory: DaemonFactory, optionsA: SpawnOptions
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       this.timeout(10 * 1000)
 
-      await daemons[0].client.dht.put(record.key, record.value)
+      await daemonA.client.dht.put(record.key, record.value)
 
-      const data = await daemons[1].client.dht.get(record.key)
+      const data = await daemonB.client.dht.get(record.key)
       expect(data).to.equalBytes(record.value)
     })
   })

package/src/dht/content-routing.ts

@@ -27,25 +27,27 @@ export function contentRoutingTests (factory: DaemonFactory): void {
 
 function runContentRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('dht.contentRouting', () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
+    let daemonC: Daemon
     let identify: IdentifyResult[]
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
+      daemonC = await factory.spawn(optionsB)
 
-      identify = await Promise.all(
-        daemons.map(async d => await d.client.identify())
-      )
+      identify = await Promise.all([
+        daemonA.client.identify(),
+        daemonB.client.identify(),
+        daemonC.client.identify()
+      ])
 
-      await daemons[0].client.connect(identify[1].peerId, identify[1].addrs)
-      await daemons[0].client.connect(identify[2].peerId, identify[2].addrs)
+      await daemonA.client.connect(identify[1].peerId, identify[1].addrs)
+      await daemonA.client.connect(identify[2].peerId, identify[2].addrs)
 
       // get the peers in the table
       await new Promise(resolve => setTimeout(resolve, 1000))
@@ -53,19 +55,19 @@ function runContentRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions,
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       const cid = CID.parse('QmVzw6MPsF96TyXBSRs1ptLoVMWRv5FCYJZZGJSVB2Hp39')
 
-      await daemons[0].client.dht.provide(cid)
+      await daemonA.client.dht.provide(cid)
 
-      const providers = await all(daemons[1].client.dht.findProviders(cid, 1))
+      const providers = await all(daemonB.client.dht.findProviders(cid, 1))
 
       expect(providers).to.exist()
       expect(providers.length).to.be.greaterThan(0)

package/src/dht/peer-routing.ts

@@ -21,41 +21,41 @@ export function peerRoutingTests (factory: DaemonFactory): void {
 
 function runPeerRoutingTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('dht.peerRouting', () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
+    let daemonC: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
+      daemonC = await factory.spawn(optionsB)
     })
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB, daemonC]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
-      const identify1 = await daemons[1].client.identify()
-      const identify2 = await daemons[2].client.identify()
+      const identify1 = await daemonB.client.identify()
+      const identify2 = await daemonC.client.identify()
 
       // peers need at least one peer in their routing table or they fail with:
       // connect 0 => 1
-      await daemons[0].client.connect(identify1.peerId, identify1.addrs)
+      await daemonA.client.connect(identify1.peerId, identify1.addrs)
 
       // connect 0 => 2
-      await daemons[0].client.connect(identify2.peerId, identify2.addrs)
+      await daemonA.client.connect(identify2.peerId, identify2.addrs)
 
       // peer 1 find peer 2, retry up to 10 times to allow the routing table to refresh
-      const peerData: PeerInfo = await pRetry(async () => await daemons[1].client.dht.findPeer(identify2.peerId), { retries: 10 })
+      const peerData: PeerInfo = await pRetry(async () => await daemonB.client.dht.findPeer(identify2.peerId), { retries: 10 })
 
       expect(identify2.addrs.map(ma => ma.toString())).to.include.deep.members(peerData.multiaddrs.map(ma => ma.toString()))
     })

package/src/pubsub/floodsub.ts

@@ -22,37 +22,34 @@ export function floodsubTests (factory: DaemonFactory): void {
 
 function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('pubsub.floodSub', () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
 
-      const [peerA, peerB] = daemons
-      const identifyB = await peerB.client.identify()
-      await peerA.client.connect(identifyB.peerId, identifyB.addrs)
+      const identifyB = await daemonB.client.identify()
+      await daemonA.client.connect(identifyB.peerId, identifyB.addrs)
     })
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       const topic = 'test-topic'
       const data = uint8ArrayFromString('test-data')
-      const [peerA, peerB] = daemons
 
-      const subscription = await peerB.client.pubsub.subscribe(topic)
+      const subscription = await daemonB.client.pubsub.subscribe(topic)
       const subscriber = async (): Promise<void> => {
         const message = await first(subscription.messages())
 
@@ -61,8 +58,8 @@ function runFloodsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optio
       }
 
       const publisher = async (): Promise<void> => {
-        await waitForSubscribed(topic, peerA, peerB)
-        await peerA.client.pubsub.publish(topic, data)
+        await waitForSubscribed(topic, daemonA, daemonB)
+        await daemonA.client.pubsub.publish(topic, data)
       }
 
       return await Promise.all([

package/src/pubsub/gossipsub.ts

@@ -22,37 +22,34 @@ export function gossipsubTests (factory: DaemonFactory): void {
 
 function runGossipsubTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('pubsub.gossipsub', () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
 
-      const [peerA, peerB] = daemons
-      const identifyB = await peerB.client.identify()
-      await peerA.client.connect(identifyB.peerId, identifyB.addrs)
+      const identifyB = await daemonB.client.identify()
+      await daemonA.client.connect(identifyB.peerId, identifyB.addrs)
     })
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async daemon => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       const topic = 'test-topic'
       const data = uint8ArrayFromString('test-data')
-      const [peerA, peerB] = daemons
 
-      const subscription = await peerB.client.pubsub.subscribe(topic)
+      const subscription = await daemonB.client.pubsub.subscribe(topic)
       const subscriber = async (): Promise<void> => {
         const message = await first(subscription.messages())
 
@@ -61,8 +58,8 @@ function runGossipsubTests (factory: DaemonFactory, optionsA: SpawnOptions, opti
       }
 
       const publisher = async (): Promise<void> => {
-        await waitForSubscribed(topic, peerA, peerB)
-        await peerA.client.pubsub.publish(topic, data)
+        await waitForSubscribed(topic, daemonA, daemonB)
+        await daemonA.client.pubsub.publish(topic, data)
       }
 
       return await Promise.all([

package/src/pubsub/hybrid.ts

@@ -22,37 +22,34 @@ export function hybridTests (factory: DaemonFactory): void {
 
 function runHybridTests (factory: DaemonFactory, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe('pubsub.hybrid', () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
 
-      const [peerA, peerB] = daemons
-      const identifyB = await peerB.client.identify()
-      await peerA.client.connect(identifyB.peerId, identifyB.addrs)
+      const identifyB = await daemonB.client.identify()
+      await daemonA.client.connect(identifyB.peerId, identifyB.addrs)
     })
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} peer to ${optionsB.type} peer`, async function () {
       const topic = 'test-topic'
       const data = uint8ArrayFromString('test-data')
-      const [peerA, peerB] = daemons
 
-      const subscription = await peerB.client.pubsub.subscribe(topic)
+      const subscription = await daemonB.client.pubsub.subscribe(topic)
       const subscriber = async (): Promise<void> => {
         const message = await first(subscription.messages())
 
@@ -61,8 +58,8 @@ function runHybridTests (factory: DaemonFactory, optionsA: SpawnOptions, options
       }
 
       const publisher = async (): Promise<void> => {
-        await waitForSubscribed(topic, peerA, peerB)
-        await peerA.client.pubsub.publish(topic, data)
+        await waitForSubscribed(topic, daemonA, daemonB)
+        await daemonA.client.pubsub.publish(topic, data)
       }
 
       return await Promise.all([

package/src/pubsub/utils.ts

@@ -17,6 +17,7 @@ export async function waitForSubscribed (topic: string, a: Daemon, b: Daemon): P
     interval: 500
   })
 
-  // wait for the gossipsub heartbeat to rebalance the mesh
+  // just having a peer in the subscriber list is not a guarentee they will recieve the
+  // message - we have to also wait for the gossipsub heartbeat to rebalance the mesh
   await delay(2000)
 }

package/src/relay/index.ts

@@ -29,7 +29,10 @@ function relayTest (factory: DaemonFactory, aType: NodeType, bType: NodeType, re
 
     beforeEach(async function () {
       this.timeout(20 * 1000)
-      ;[aNode, bNode, relay] = await Promise.all(opts.map(async o => await factory.spawn(o)))
+      aNode = await factory.spawn(opts[0])
+      bNode = await factory.spawn(opts[1])
+      relay = await factory.spawn(opts[2])
+
       ;[bId, relayId] = await Promise.all([bNode, relay].map(async d => await d.client.identify()))
 
       // construct a relay address
@@ -40,7 +43,11 @@ function relayTest (factory: DaemonFactory, aType: NodeType, bType: NodeType, re
     })
 
     afterEach(async function () {
-      await Promise.all([aNode, bNode, relay].map(async d => { await d.stop() }))
+      await Promise.all([aNode, bNode, relay].map(async d => {
+        if (d != null) {
+          await d.stop()
+        }
+      }))
     })
 
     it('connects', async () => {

package/src/streams/echo.ts

@@ -24,21 +24,20 @@ export function echoStreamTests (factory: DaemonFactory, muxer: Muxer): void {
 
 function runEchoStreamTests (factory: DaemonFactory, muxer: Muxer, optionsA: SpawnOptions, optionsB: SpawnOptions): void {
   describe(`echo streams - ${muxer}`, () => {
-    let daemons: Daemon[]
+    let daemonA: Daemon
+    let daemonB: Daemon
 
     // Start Daemons
     before(async function () {
       this.timeout(20 * 1000)
 
-      daemons = await Promise.all([
-        factory.spawn(optionsA),
-        factory.spawn(optionsB)
-      ])
+      daemonA = await factory.spawn(optionsA)
+      daemonB = await factory.spawn(optionsB)
 
       // connect them
-      const identify0 = await daemons[0].client.identify()
+      const identify0 = await daemonA.client.identify()
 
-      await daemons[1].client.connect(identify0.peerId, identify0.addrs)
+      await daemonB.client.connect(identify0.peerId, identify0.addrs)
 
       // jsDaemon1 will take some time to get the peers
       await new Promise(resolve => setTimeout(resolve, 1000))
@@ -46,21 +45,21 @@ function runEchoStreamTests (factory: DaemonFactory, muxer: Muxer, optionsA: Spa
 
     // Stop daemons
     after(async function () {
-      if (daemons != null) {
-        await Promise.all(
-          daemons.map(async (daemon) => { await daemon.stop() })
-        )
-      }
+      await Promise.all(
+        [daemonA, daemonB]
+          .filter(Boolean)
+          .map(async d => { await d.stop() })
+      )
     })
 
     it(`${optionsA.type} sender to ${optionsB.type} listener`, async function () {
       this.timeout(10 * 1000)
 
-      const receivingIdentity = await daemons[1].client.identify()
+      const receivingIdentity = await daemonB.client.identify()
       const protocol = '/echo/1.0.0'
       const input = [uint8ArrayFromString('hello world')]
 
-      await daemons[1].client.registerStreamHandler(protocol, async (stream) => {
+      await daemonB.client.registerStreamHandler(protocol, async (stream) => {
         await pipe(
           stream,
           async function * (source) {
@@ -72,7 +71,7 @@ function runEchoStreamTests (factory: DaemonFactory, muxer: Muxer, optionsA: Spa
         )
       })
 
-      const stream = await daemons[0].client.openStream(receivingIdentity.peerId, protocol)
+      const stream = await daemonA.client.openStream(receivingIdentity.peerId, protocol)
 
       // without this the socket can close before we receive a response
       const responseReceived = defer()