tests: update ipfsd-ctl

This new version of ipfsd-ctl is using async/await instead of callbacks.
Hence some rather mechanical changes are needed for tests.

Author: vmx

package.json

@@ -190,7 +190,7 @@
     "form-data": "^2.5.0",
     "hat": "0.0.3",
     "interface-ipfs-core": "^0.109.1",
-    "ipfsd-ctl": "^0.43.0",
+    "ipfsd-ctl": "^0.44.1",
     "libp2p-websocket-star": "~0.10.2",
     "ncp": "^2.0.0",
     "qs": "^6.5.2",

test/bootstrapers.js

@@ -1,10 +1,6 @@
 /* eslint-env mocha */
 'use strict'
 
-const chai = require('chai')
-const dirtyChai = require('dirty-chai')
-const expect = chai.expect
-chai.use(dirtyChai)
 const IPFS = require('..')
 const IPFSFactory = require('ipfsd-ctl')
 const bootstrapList = require('../src/core/runtime/config-browser.js')().Bootstrap
@@ -17,25 +13,21 @@ const waitFor = require('./utils/wait-for')
 describe('Check that a js-ipfs node can indeed contact the bootstrappers', () => {
   let ipfsd
 
-  before(function (done) {
+  before(async () => {
     this.timeout(30 * 1000)
 
     const factory = IPFSFactory.create({ type: 'proc', exec: IPFS })
 
-    factory.spawn({
+    ipfsd = await factory.spawn({
       config: {
         Addresses: {
           Swarm: []
         }
       }
-    }, (err, node) => {
-      expect(err).to.not.exist()
-      ipfsd = node
-      done()
     })
   })
 
-  after(done => ipfsd.stop(done))
+  after(() => ipfsd.stop())
 
   it('a node connects to bootstrappers', function (done) {
     this.timeout(2 * 60 * 1000)

test/cli/dht.js

@@ -7,7 +7,6 @@ const dirtyChai = require('dirty-chai')
 const expect = chai.expect
 chai.use(dirtyChai)
 
-const series = require('async/series')
 const parallel = require('async/parallel')
 const path = require('path')
 const DaemonFactory = require('ipfsd-ctl')
@@ -41,24 +40,16 @@ describe.skip('dht', () => {
   let multiaddrB
 
   // spawn daemons
-  before(function (done) {
+  before(async function () {
     this.timeout(80 * 1000)
-    series([
-      (cb) => df.spawn(daemonOpts, (err, _ipfsd) => {
-        expect(err).to.not.exist()
 
-        ipfsA = ipfsExec(_ipfsd.repoPath)
-        nodes.push(_ipfsd)
-        cb()
-      }),
-      (cb) => df.spawn(daemonOpts, (err, _ipfsd) => {
-        expect(err).to.not.exist()
+    const ipfsdA = await df.spawn(daemonOpts)
+    ipfsA = ipfsExec(ipfsdA.repoPath)
+    nodes.push(ipfsdA)
 
-        ipfsB = ipfsExec(_ipfsd.repoPath)
-        nodes.push(_ipfsd)
-        cb()
-      })
-    ], done)
+    const ipfsdB = await df.spawn(daemonOpts)
+    ipfsB = ipfsExec(ipfsdB.repoPath)
+    nodes.push(ipfsdB)
   })
 
   // get ids
@@ -88,7 +79,7 @@ describe.skip('dht', () => {
     nodes[0].api.swarm.connect(multiaddrB, done)
   })
 
-  after((done) => parallel(nodes.map((node) => (cb) => node.stop(cb)), done))
+  after(() => Promise.all(nodes.map((node) => node.stop())))
 
   it('should be able to put a value to the dht and get it afterwards', function () {
     this.timeout(60 * 1000)

test/cli/name-pubsub.js

@@ -8,30 +8,27 @@ const expect = chai.expect
 chai.use(dirtyChai)
 const path = require('path')
 const parallel = require('async/parallel')
-const series = require('async/series')
 const ipfsExec = require('../utils/ipfs-exec')
 
 const DaemonFactory = require('ipfsd-ctl')
 const df = DaemonFactory.create({ type: 'js' })
 
-const spawnDaemon = (callback) => {
-  df.spawn({
-    exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
-    args: ['--enable-namesys-pubsub'],
-    initOptions: { bits: 512 },
-    config: {
-      Bootstrap: [],
-      Discovery: {
-        MDNS: {
-          Enabled: false
-        },
-        webRTCStar: {
-          Enabled: false
-        }
+const spawnDaemon = () => df.spawn({
+  exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
+  args: ['--enable-namesys-pubsub'],
+  initOptions: { bits: 512 },
+  config: {
+    Bootstrap: [],
+    Discovery: {
+      MDNS: {
+        Enabled: false
+      },
+      webRTCStar: {
+        Enabled: false
       }
     }
-  }, callback)
-}
+  }
+})
 
 describe('name-pubsub', () => {
   describe('enabled', () => {
@@ -43,29 +40,18 @@ describe('name-pubsub', () => {
     const nodes = []
 
     // Spawn daemons
-    before(function (done) {
+    before(async function () {
       // CI takes longer to instantiate the daemon, so we need to increase the
       // timeout for the before step
       this.timeout(80 * 1000)
 
-      series([
-        (cb) => {
-          spawnDaemon((err, node) => {
-            expect(err).to.not.exist()
-            ipfsA = ipfsExec(node.repoPath)
-            nodes.push(node)
-            cb()
-          })
-        },
-        (cb) => {
-          spawnDaemon((err, node) => {
-            expect(err).to.not.exist()
-            ipfsB = ipfsExec(node.repoPath)
-            nodes.push(node)
-            cb()
-          })
-        }
-      ], done)
+      const nodeA = await spawnDaemon()
+      ipfsA = ipfsExec(nodeA.repoPath)
+      nodes.push(nodeA)
+
+      const nodeB = await spawnDaemon()
+      ipfsB = ipfsExec(nodeB.repoPath)
+      nodes.push(nodeB)
     })
 
     // Get node ids
@@ -97,7 +83,7 @@ describe('name-pubsub', () => {
         })
     })
 
-    after((done) => parallel(nodes.map((node) => (cb) => node.stop(cb)), done))
+    after(() => Promise.all(nodes.map((node) => node.stop())))
 
     describe('pubsub commands', () => {
       it('should get enabled state of pubsub', function () {
@@ -166,27 +152,27 @@ describe('name-pubsub', () => {
 
   describe('disabled', () => {
     let ipfsA
-    const nodes = []
+    let node
 
     // Spawn daemons
-    before(function (done) {
+    before(async function () {
       // CI takes longer to instantiate the daemon, so we need to increase the
       // timeout for the before step
       this.timeout(80 * 1000)
 
-      df.spawn({
+      node = await df.spawn({
         exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
         config: {},
         initOptions: { bits: 512 }
-      }, (err, node) => {
-        expect(err).to.not.exist()
-        ipfsA = ipfsExec(node.repoPath)
-        nodes.push(node)
-        done()
       })
+      ipfsA = ipfsExec(node.repoPath)
     })
 
-    after((done) => parallel(nodes.map((node) => (cb) => node.stop(cb)), done))
+    after(() => {
+      if (node) {
+        return node.stop()
+      }
+    })
 
     it('should get disabled state of pubsub', function () {
       return ipfsA('name pubsub state')

test/cli/ping.js

@@ -4,7 +4,6 @@
 
 const chai = require('chai')
 const dirtyChai = require('dirty-chai')
-const series = require('async/series')
 const DaemonFactory = require('ipfsd-ctl')
 const ipfsExec = require('../utils/ipfs-exec')
 const path = require('path')
@@ -30,44 +29,29 @@ describe('ping', function () {
   let ipfsdBId
   let cli
 
-  before((done) => {
+  before(async function () {
     this.timeout(60 * 1000)
-    series([
-      (cb) => {
-        df.spawn({
-          exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
-          config,
-          initOptions: { bits: 512 }
-        }, (err, _ipfsd) => {
-          expect(err).to.not.exist()
-          ipfsdB = _ipfsd
-          cb()
-        })
-      },
-      (cb) => {
-        ipfsdB.api.id((err, peerInfo) => {
-          expect(err).to.not.exist()
-          ipfsdBId = peerInfo.id
-          bMultiaddr = peerInfo.addresses[0]
-          cb()
-        })
-      }
-    ], done)
+
+    ipfsdB = await df.spawn({
+      exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
+      config,
+      initOptions: { bits: 512 }
+    })
+    const peerInfo = await ipfsdB.api.id()
+    ipfsdBId = peerInfo.id
+    bMultiaddr = peerInfo.addresses[0]
   })
 
-  before(function (done) {
+  before(async function () {
     this.timeout(60 * 1000)
 
-    df.spawn({
+    ipfsdA = await df.spawn({
       exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
       config,
-      initoptions: { bits: 512 }
-    }, (err, _ipfsd) => {
-      expect(err).to.not.exist()
-      ipfsdA = _ipfsd
-      // Without DHT we need to have an already established connection
-      ipfsdA.api.swarm.connect(bMultiaddr, done)
+      initOptions: { bits: 512 }
     })
+    // Without DHT we need to have an already established connection
+    await ipfsdA.api.swarm.connect(bMultiaddr)
   })
 
   before((done) => {
@@ -76,14 +60,15 @@ describe('ping', function () {
     done()
   })
 
-  after((done) => {
-    if (!ipfsdA) return done()
-    ipfsdA.stop(done)
+  after(() => {
+    if (ipfsdA) {
+      return ipfsdA.stop()
+    }
   })
-
-  after((done) => {
-    if (!ipfsdB) return done()
-    ipfsdB.stop(done)
+  after(() => {
+    if (ipfsdB) {
+      return ipfsdB.stop()
+    }
   })
 
   it('ping host', (done) => {

test/cli/pubsub.js

@@ -12,7 +12,6 @@ const ipfsExec = require('../utils/ipfs-exec')
 const IPFS = require('../../src')
 const path = require('path')
 const DaemonFactory = require('ipfsd-ctl')
-const df = DaemonFactory.create({ type: 'js' })
 
 const config = {
   Bootstrap: [],
@@ -37,43 +36,47 @@ describe('pubsub', function () {
   const topicB = 'nonscentsB'
   const topicC = 'nonscentsC'
 
-  before(function (done) {
+  before(async function () {
     this.timeout(60 * 1000)
 
-    DaemonFactory
-      .create({ type: 'proc' })
-      .spawn({
-        exec: IPFS,
-        initOptions: { bits: 512 },
-        config,
-        args: ['--enable-pubsub-experiment']
-      }, (err, _ipfsd) => {
-        expect(err).to.not.exist()
-        ipfsdA = _ipfsd
-        node = _ipfsd.api
-        done()
-      })
+    const df = DaemonFactory.create({ type: 'proc' })
+    ipfsdA = await df.spawn({
+      exec: IPFS,
+      initOptions: { bits: 512 },
+      config,
+      args: ['--enable-pubsub-experiment']
+    })
+    node = ipfsdA.api
   })
 
-  after((done) => ipfsdB.stop(done))
+  after(() => {
+    if (ipfsdB) {
+      return ipfsdB.stop()
+    }
+  })
 
-  before((done) => {
-    df.spawn({
+  before(async () => {
+    const df = DaemonFactory.create({ type: 'js' })
+    ipfsdB = await df.spawn({
       initOptions: { bits: 512 },
       args: ['--enable-pubsub-experiment'],
       exec: path.resolve(`${__dirname}/../../src/cli/bin.js`),
       config
-    }, (err, _ipfsd) => {
-      expect(err).to.not.exist()
-      httpApi = _ipfsd.api
-      ipfsdB = _ipfsd
-      httpApi.repoPath = ipfsdB.repoPath
-      done()
     })
+    httpApi = ipfsdB.api
+    httpApi.repoPath = ipfsdB.repoPath
   })
 
-  after((done) => ipfsdA.stop(done))
-  after((done) => ipfsdB.stop(done))
+  after(() => {
+    if (ipfsdA) {
+      return ipfsdA.stop()
+    }
+  })
+  after(() => {
+    if (ipfsdB) {
+      return ipfsdB.stop()
+    }
+  })
 
   before((done) => {
     cli = ipfsExec(httpApi.repoPath)