refactor: miscellaneous before and after methods to async syntax

Author: Pedro Santos

src/miscellaneous/dns.js

@@ -13,24 +13,11 @@ module.exports = (createCommon, options) => {
     this.retries(3)
     let ipfs
 
-    before(function (done) {
-      // CI takes longer to instantiate the daemon, so we need to increase the
-      // timeout for the before step
-      this.timeout(60 * 1000)
-
-      common.setup((err, factory) => {
-        expect(err).to.not.exist()
-        factory.spawnNode((err, node) => {
-          expect(err).to.not.exist()
-          ipfs = node
-          done()
-        })
-      })
+    before(async () => {
+      ipfs = await common.setup()
     })
 
-    after((done) => {
-      common.teardown(done)
-    })
+    after(() => common.teardown())
 
     it('should non-recursively resolve ipfs.io', async () => {
       const res = await ipfs.dns('ipfs.io', { recursive: false })

src/miscellaneous/id.js

@@ -12,20 +12,11 @@ module.exports = (createCommon, options) => {
     this.timeout(60 * 1000)
     let ipfs
 
-    before(function (done) {
-      common.setup((err, factory) => {
-        expect(err).to.not.exist()
-        factory.spawnNode((err, node) => {
-          expect(err).to.not.exist()
-          ipfs = node
-          done()
-        })
-      })
+    before(async () => {
+      ipfs = await common.setup()
     })
 
-    after((done) => {
-      common.teardown(done)
-    })
+    after(() => common.teardown())
 
     it('should get the node ID', async () => {
       const res = await ipfs.id()

src/miscellaneous/resolve.js

@@ -6,8 +6,6 @@ const isIpfs = require('is-ipfs')
 const loadFixture = require('aegir/fixtures')
 const hat = require('hat')
 const multibase = require('multibase')
-const { spawnNodeWithId } = require('../utils/spawn')
-const { connect } = require('../utils/swarm')
 const { getDescribe, getIt, expect } = require('../utils/mocha')
 
 module.exports = (createCommon, options) => {
@@ -18,22 +16,12 @@ module.exports = (createCommon, options) => {
   describe('.resolve', function () {
     this.timeout(60 * 1000)
     let ipfs
-    let nodeId
-
-    before(function (done) {
-      common.setup((err, factory) => {
-        expect(err).to.not.exist()
-        spawnNodeWithId(factory, (err, node) => {
-          expect(err).to.not.exist()
-
-          ipfs = node
-          nodeId = node.peerId.id
-          done()
-        })
-      })
+
+    before(async () => {
+      ipfs = await common.setup()
     })
 
-    after(common.teardown)
+    after(() => common.teardown())
 
     it('should resolve an IPFS hash', async () => {
       const content = loadFixture('test/fixtures/testfile.txt', 'interface-ipfs-core')
@@ -89,25 +77,14 @@ module.exports = (createCommon, options) => {
     })
 
     it('should resolve IPNS link recursively', async function () {
-      this.timeout(20 * 1000)
-
-      // Ensure another node exists for publishing to
-      await new Promise((resolve, reject) => {
-        common.setup((err, factory) => {
-          if (err) return reject(err)
-          spawnNodeWithId(factory, (err, node) => {
-            if (err) return reject(err)
-            const addr = node.peerId.addresses.find((a) => a.includes('127.0.0.1'))
-            connect(ipfs, addr, resolve)
-          })
-        })
-      })
+      const node = await common.setup()
+      await ipfs.swarm.connect(node.peerId.addresses.find((a) => a.includes('127.0.0.1')))
 
       const [{ path }] = await ipfs.add(Buffer.from('should resolve a record recursive === true'))
       const { id: keyId } = await ipfs.key.gen('key-name', { type: 'rsa', size: 2048 })
 
       await ipfs.name.publish(path, { allowOffline: true })
-      await ipfs.name.publish(`/ipns/${nodeId}`, { allowOffline: true, key: 'key-name', resolve: false })
+      await ipfs.name.publish(`/ipns/${ipfs.peerId.id}`, { allowOffline: true, key: 'key-name', resolve: false })
 
       return expect(await ipfs.resolve(`/ipns/${keyId}`, { recursive: true }))
         .to.eq(`/ipfs/${path}`)

src/miscellaneous/stop.js

@@ -8,30 +8,16 @@ module.exports = (createCommon, options) => {
   const it = getIt(options)
   const common = createCommon()
 
-  describe('.stop', () => {
+  describe('.stop', function () {
+    this.timeout(60 * 1000)
     let ipfs
 
-    before(function (done) {
-      // CI takes longer to instantiate the daemon, so we need to increase the
-      // timeout for the before step
-      this.timeout(60 * 1000)
-
-      common.setup((err, factory) => {
-        expect(err).to.not.exist()
-        factory.spawnNode((err, node) => {
-          expect(err).to.not.exist()
-          ipfs = node
-          done()
-        })
-      })
-    })
-
-    after((done) => {
-      common.teardown(done)
+    before(async () => {
+      ipfs = await common.setup()
     })
 
     // must be last test to run
-    it('should stop the node2', async function () {
+    it('should stop the node', async function () {
       this.timeout(10 * 1000)
 
       await ipfs.stop()

src/miscellaneous/version.js

@@ -8,27 +8,15 @@ module.exports = (createCommon, options) => {
   const it = getIt(options)
   const common = createCommon()
 
-  describe('.version', () => {
+  describe('.version', function () {
+    this.timeout(60 * 1000)
     let ipfs
 
-    before(function (done) {
-      // CI takes longer to instantiate the daemon, so we need to increase the
-      // timeout for the before step
-      this.timeout(60 * 1000)
-
-      common.setup((err, factory) => {
-        expect(err).to.not.exist()
-        factory.spawnNode((err, node) => {
-          expect(err).to.not.exist()
-          ipfs = node
-          done()
-        })
-      })
+    before(async () => {
+      ipfs = await common.setup()
     })
 
-    after((done) => {
-      common.teardown(done)
-    })
+    after(() => common.teardown())
 
     it('should get the node version', async () => {
       const result = await ipfs.version()