fix: support new ctl in core and http tests

Author: hugomrdias

package.json

@@ -160,6 +160,7 @@
     "multihashing-async": "^0.8.0",
     "node-fetch": "^2.3.0",
     "p-iteration": "^1.1.8",
+    "p-map": "^3.0.0",
     "p-queue": "^6.1.0",
     "peer-book": "^0.9.1",
     "peer-id": "^0.12.2",

test/core/bitswap.spec.js

@@ -1,257 +1,91 @@
-/* eslint max-nested-callbacks: ["error", 8] */
 /* eslint-env mocha */
 'use strict'
 
 const hat = require('hat')
+const pmap = require('p-map')
 const { expect } = require('interface-ipfs-core/src/utils/mocha')
-const _ = require('lodash')
-const series = require('async/series')
-const waterfall = require('async/waterfall')
-const parallel = require('async/parallel')
 const Block = require('ipfs-block')
-const multiaddr = require('multiaddr')
-const { isNode } = require('ipfs-utils/src/env')
 const multihashing = require('multihashing-async')
 const CID = require('cids')
-const path = require('path')
-const IPFSFactory = require('ipfsd-ctl')
-const callbackify = require('callbackify')
-const IPFSHTTPClient = require('ipfs-http-client')
+const factory = require('../utils/factory')
 
-const IPFS = require('../../src/core')
-
-function makeBlock (callback) {
+const makeBlock = async () => {
   const d = Buffer.from(`IPFS is awesome ${hat()}`)
+  const h = await multihashing(d, 'sha2-256')
 
-  callbackify(multihashing)(d, 'sha2-256', null, (err, multihash) => {
-    if (err) {
-      return callback(err)
-    }
-    callback(null, new Block(d, new CID(multihash)))
-  })
-}
-
-function wire (targetNode, dialerNode, callback) {
-  targetNode.id((err, identity) => {
-    expect(err).to.not.exist()
-    const addr = identity.addresses
-      .map((addr) => multiaddr(addr.toString().split('ipfs')[0]))
-      .filter((addr) => _.includes(addr.protoNames(), 'ws'))[0]
-
-    if (!addr) {
-      // Note: the browser doesn't have a websockets listening addr
-      return callback()
-    }
-
-    const targetAddr = addr
-      .encapsulate(multiaddr(`/ipfs/${identity.id}`)).toString()
-      .replace('0.0.0.0', '127.0.0.1')
-
-    dialerNode.swarm.connect(targetAddr, callback)
-  })
-}
-
-function connectNodes (remoteNode, inProcNode, callback) {
-  series([
-    (cb) => wire(remoteNode, inProcNode, cb),
-    // need timeout so we wait for identify to happen.
-    // This call is just to ensure identify happened
-    (cb) => setTimeout(() => wire(inProcNode, remoteNode, cb), 500)
-  ], callback)
-}
-
-let nodes = []
-
-function addNode (fDaemon, inProcNode, callback) {
-  callbackify.variadic(fDaemon.spawn.bind(fDaemon))({
-    exec: isNode ? path.resolve(`${__dirname}/../../src/cli/bin.js`) : './src/cli/bin.js',
-    initOptions: { bits: 512 },
-    config: {
-      Addresses: {
-        Swarm: ['/ip4/127.0.0.1/tcp/0/ws']
-      },
-      Discovery: {
-        MDNS: {
-          Enabled: false
-        }
-      },
-      Bootstrap: []
-    },
-    preload: { enabled: false }
-  }, (err, ipfsd) => {
-    expect(err).to.not.exist()
-    nodes.push(ipfsd)
-    connectNodes(ipfsd.api, inProcNode, (err) => {
-      callback(err, ipfsd.api)
-    })
-  })
+  return new Block(d, new CID(h))
 }
 
 describe('bitswap', function () {
-  this.timeout(80 * 1000)
-
-  let inProcNode // Node spawned inside this process
-  let fDaemon
-  let fInProc
-
-  before(function () {
-    fDaemon = IPFSFactory.create({
-      type: 'js',
-      IpfsClient: require('ipfs-http-client')
-    })
-    fInProc = IPFSFactory.create({
-      type: 'proc',
-      IpfsClient: require('ipfs-http-client')
-    })
-  })
-
-  beforeEach(async function () {
-    this.timeout(60 * 1000)
-
-    let config = {
-      Addresses: {
-        Swarm: []
-      },
-      Discovery: {
-        MDNS: {
-          Enabled: false
-        }
-      },
-      Bootstrap: []
-    }
-
-    if (isNode) {
-      config = Object.assign({}, config, {
-        Addresses: {
-          Swarm: ['/ip4/127.0.0.1/tcp/0']
-        }
-      })
-    }
-
-    const ipfsd = await fInProc.spawn({
-      exec: IPFS,
-      IPFSClient: IPFSHTTPClient,
-      config: config,
-      initOptions: { bits: 512 },
-      start: true,
-      init: true
-    })
-    nodes.push(ipfsd)
-    inProcNode = ipfsd.api
-  })
-
-  afterEach(async function () {
-    this.timeout(80 * 1000)
-    await Promise.all(
-      nodes.map((node) => node.stop())
-    )
-    nodes = []
-  })
+  this.timeout(20 * 1000)
+  const df = factory()
 
   describe('transfer a block between', () => {
-    it('2 peers', function (done) {
-      this.timeout(160 * 1000)
-
-      let remoteNode
-      let block
-      waterfall([
-        (cb) => parallel([
-          (cb) => makeBlock(cb),
-          (cb) => addNode(fDaemon, inProcNode, cb)
-        ], cb),
-        (res, cb) => {
-          block = res[0]
-          remoteNode = res[1]
-          cb()
-        },
-        (cb) => remoteNode.block.put(block, cb),
-        (key, cb) => inProcNode.block.get(block.cid, cb),
-        (b, cb) => {
-          expect(b.data).to.eql(block.data)
-          cb()
-        }
-      ], done)
-    })
+    it('2 peers', async function () {
+      const remote = (await df.spawn({ type: 'js' })).api
+      const proc = (await df.spawn({ type: 'proc' })).api
+      proc.swarm.connect(remote.peerId.addresses[0])
+      const block = await makeBlock()
 
-    it('3 peers', function (done) {
-      this.timeout(160 * 1000)
+      await proc.block.put(block)
+      const b = await remote.block.get(block.cid)
 
-      let blocks
-      const remoteNodes = []
-
-      series([
-        (cb) => parallel(_.range(6).map((i) => makeBlock), (err, _blocks) => {
-          expect(err).to.not.exist()
-          blocks = _blocks
-          cb()
-        }),
-        (cb) => addNode(fDaemon, inProcNode, (err, _ipfs) => {
-          remoteNodes.push(_ipfs)
-          cb(err)
-        }),
-        (cb) => addNode(fDaemon, inProcNode, (err, _ipfs) => {
-          remoteNodes.push(_ipfs)
-          cb(err)
-        }),
-        (cb) => connectNodes(remoteNodes[0], remoteNodes[1], cb),
-        (cb) => remoteNodes[0].block.put(blocks[0], cb),
-        (cb) => remoteNodes[0].block.put(blocks[1], cb),
-        (cb) => remoteNodes[1].block.put(blocks[2], cb),
-        (cb) => remoteNodes[1].block.put(blocks[3], cb),
-        (cb) => inProcNode.block.put(blocks[4], cb),
-        (cb) => inProcNode.block.put(blocks[5], cb),
-        // 3. Fetch blocks on all nodes
-        (cb) => parallel(_.range(6).map((i) => (cbI) => {
-          const check = (n, cid, callback) => {
-            n.block.get(cid, (err, b) => {
-              expect(err).to.not.exist()
-              expect(b).to.eql(blocks[i])
-              callback()
-            })
-          }
+      expect(b.data).to.eql(block.data)
+      df.clean()
+    })
 
-          series([
-            (cbJ) => check(remoteNodes[0], blocks[i].cid, cbJ),
-            (cbJ) => check(remoteNodes[1], blocks[i].cid, cbJ),
-            (cbJ) => check(inProcNode, blocks[i].cid, cbJ)
-          ], cbI)
-        }), cb)
-      ], done)
+    it('3 peers', async () => {
+      const blocks = await Promise.all([...Array(6).keys()].map(() => makeBlock()))
+      const remote1 = (await df.spawn({ type: 'js' })).api
+      const remote2 = (await df.spawn({ type: 'js' })).api
+      const proc = (await df.spawn({ type: 'proc' })).api
+      proc.swarm.connect(remote1.peerId.addresses[0])
+      proc.swarm.connect(remote2.peerId.addresses[0])
+      remote1.swarm.connect(remote2.peerId.addresses[0])
+
+      await remote1.block.put(blocks[0])
+      await remote1.block.put(blocks[1])
+      await remote2.block.put(blocks[2])
+      await remote2.block.put(blocks[3])
+      await proc.block.put(blocks[4])
+      await proc.block.put(blocks[5])
+
+      await pmap(blocks, async (block) => {
+        expect(await remote1.block.get(block.cid)).to.eql(block)
+        expect(await remote2.block.get(block.cid)).to.eql(block)
+        expect(await proc.block.get(block.cid)).to.eql(block)
+      }, { concurrency: 3 })
+      df.clean()
     })
   })
 
-  describe('transfer a file between', function () {
-    this.timeout(160 * 1000)
-
-    it('2 peers', (done) => {
+  describe('transfer a file between', () => {
+    it('2 peers', async () => {
       // TODO make this test more interesting (10Mb file)
       // TODO remove randomness from the test
       const file = Buffer.from(`I love IPFS <3 ${hat()}`)
-
-      waterfall([
-        // 0. Start node
-        (cb) => addNode(fDaemon, inProcNode, cb),
-        // 1. Add file to tmp instance
-        (remote, cb) => {
-          remote.add([{ path: 'awesome.txt', content: file }], cb)
-        },
-        // 2. Request file from local instance
-        (filesAdded, cb) => inProcNode.cat(filesAdded[0].hash, cb)
-      ], (err, data) => {
-        expect(err).to.not.exist()
-        expect(data).to.eql(file)
-        done()
-      })
+      const remote = (await df.spawn({ type: 'js' })).api
+      const proc = (await df.spawn({ type: 'proc' })).api
+      proc.swarm.connect(remote.peerId.addresses[0])
+
+      const files = await remote.add([{ path: 'awesome.txt', content: file }])
+      const data = await proc.cat(files[0].hash)
+      expect(data).to.eql(file)
+      df.clean()
     })
   })
 
   describe('unwant', () => {
-    it('should callback with error for invalid CID input', (done) => {
-      inProcNode.bitswap.unwant('INVALID CID', (err) => {
+    it('should callback with error for invalid CID input', async () => {
+      const proc = (await df.spawn({ type: 'proc' })).api
+      try {
+        await proc.bitswap.unwant('INVALID CID')
+      } catch (err) {
         expect(err).to.exist()
         expect(err.code).to.equal('ERR_INVALID_CID')
-        done()
-      })
+      } finally {
+        df.clean()
+      }
     })
   })
 })

test/core/block.spec.js

@@ -4,33 +4,17 @@
 
 const { expect } = require('interface-ipfs-core/src/utils/mocha')
 const hat = require('hat')
-
-const IPFSFactory = require('ipfsd-ctl')
-const IPFS = require('../../src/core')
+const factory = require('../utils/factory')
 
 describe('block', () => {
-  let ipfsd, ipfs
-
-  before(async function () {
-    const factory = IPFSFactory.create({
-      type: 'proc',
-      IpfsClient: require('ipfs-http-client')
-    })
+  let ipfs
+  const df = factory()
 
-    ipfsd = await factory.spawn({
-      exec: IPFS,
-      initOptions: { bits: 512 },
-      config: { Bootstrap: [] },
-      preload: { enabled: false }
-    })
-    ipfs = ipfsd.api
+  before(async () => {
+    ipfs = (await df.spawn()).api
   })
 
-  after(() => {
-    if (ipfsd) {
-      return ipfsd.stop()
-    }
-  })
+  after(() => df.clean())
 
   describe('get', () => {
     it('should callback with error for invalid CID input', (done) => {