chore: re-add bitswap tests

Originally from PR #267

License: MIT
Signed-off-by: Alan Shaw <[email protected]>

Author: alanshaw

js/src/bitswap/index.js

@@ -0,0 +1,10 @@
+'use strict'
+const { createSuite } = require('../utils/suite')
+
+const tests = {
+  stat: require('./stat'),
+  wantlist: require('./wantlist'),
+  unwant: require('./unwant')
+}
+
+module.exports = createSuite(tests)

js/src/bitswap/stat.js

@@ -0,0 +1,62 @@
+/* eslint-env mocha */
+'use strict'
+
+const waterfall = require('async/waterfall')
+const { getDescribe, getIt, expect } = require('../utils/mocha')
+const { expectIsBitswap } = require('../stats/utils')
+
+module.exports = (createCommon, options) => {
+  const describe = getDescribe(options)
+  const it = getIt(options)
+  const common = createCommon()
+
+  describe('.bitswap.stat', () => {
+    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))
+
+    it('should get bitswap stats', (done) => {
+      ipfs.bitswap.stat((err, res) => {
+        expectIsBitswap(err, res)
+        done()
+      })
+    })
+
+    it('should get bitswap stats (promised)', () => {
+      return ipfs.bitswap.stat().then((res) => {
+        expectIsBitswap(null, res)
+      })
+    })
+
+    it('should not get bitswap stats when offline', function (done) {
+      this.timeout(60 * 1000)
+
+      waterfall([
+        (cb) => createCommon().setup(cb),
+        (factory, cb) => factory.spawnNode(cb),
+        (node, cb) => node.stop((err) => cb(err, node))
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        node.bitswap.wantlist((err) => {
+          expect(err).to.exist()
+          done()
+        })
+      })
+    })
+  })
+}

js/src/bitswap/unwant.js

@@ -0,0 +1,76 @@
+/* eslint-env mocha */
+'use strict'
+
+const waterfall = require('async/waterfall')
+const { waitUntilConnected } = require('../utils/connections')
+const { spawnNodes } = require('../utils/spawn')
+const { getDescribe, getIt, expect } = require('../utils/mocha')
+const { waitForWantlistKey } = require('./utils')
+
+module.exports = (createCommon, options) => {
+  const describe = getDescribe(options)
+  const it = getIt(options)
+  const common = createCommon()
+
+  describe('.bitswap.unwant', () => {
+    let ipfsA
+    let ipfsB
+    const key = 'QmUBdnXXPyoDFXj3Hj39dNJ5VkN3QFRskXxcGaYFBB8CNR'
+
+    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()
+
+        spawnNodes(2, factory, (err, nodes) => {
+          expect(err).to.not.exist()
+
+          ipfsA = nodes[0]
+          ipfsB = nodes[1]
+
+          // Add key to the wantlist for ipfsB
+          ipfsB.block.get(key, () => {})
+
+          waitUntilConnected(ipfsA, ipfsB, done)
+        })
+      })
+    })
+
+    after((done) => common.teardown(done))
+
+    it('should remove a key from the wantlist', (done) => {
+      waitForWantlistKey(ipfsB, key, (err) => {
+        expect(err).to.not.exist()
+
+        ipfsB.bitswap.unwant(key, (err) => {
+          expect(err).to.not.exist()
+
+          ipfsB.bitswap.wantlist((err, list) => {
+            expect(err).to.not.exist()
+            expect(list.Keys.every(k => k['/'] !== key)).to.equal(true)
+            done()
+          })
+        })
+      })
+    })
+
+    it('should not remove a key from the wantlist when offline', function (done) {
+      this.timeout(60 * 1000)
+
+      waterfall([
+        (cb) => createCommon().setup(cb),
+        (factory, cb) => factory.spawnNode(cb),
+        (node, cb) => node.stop((err) => cb(err, node))
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        node.bitswap.wantlist((err) => {
+          expect(err).to.exist()
+          done()
+        })
+      })
+    })
+  })
+}

js/src/bitswap/utils.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const until = require('async/until')
+
+function waitForWantlistKey (ipfs, key, opts, cb) {
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = {}
+  }
+
+  opts = opts || {}
+  opts.timeout = opts.timeout || 1000
+
+  let list = { Keys: [] }
+  let timedOut = false
+
+  setTimeout(() => { timedOut = true }, opts.timeout)
+
+  const test = () => timedOut ? true : list.Keys.every(k => k['/'] === key)
+  const iteratee = (cb) => ipfs.bitswap.wantlist(opts.peerId, cb)
+
+  until(test, iteratee, (err) => {
+    if (err) return cb(err)
+    if (timedOut) return cb(new Error(`Timed out waiting for ${key} in wantlist`))
+    cb()
+  })
+}
+
+module.exports.waitForWantlistKey = waitForWantlistKey

js/src/bitswap/wantlist.js

@@ -0,0 +1,74 @@
+/* eslint-env mocha */
+'use strict'
+
+const waterfall = require('async/waterfall')
+const { waitUntilConnected } = require('../utils/connections')
+const { spawnNodes } = require('../utils/spawn')
+const { getDescribe, getIt, expect } = require('../utils/mocha')
+const { waitForWantlistKey } = require('./utils')
+
+module.exports = (createCommon, options) => {
+  const describe = getDescribe(options)
+  const it = getIt(options)
+  const common = createCommon()
+
+  describe('.bitswap.wantlist', () => {
+    let ipfsA
+    let ipfsB
+    const key = 'QmUBdnXXPyoDFXj3Hj39dNJ5VkN3QFRskXxcGaYFBB8CNR'
+
+    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()
+
+        spawnNodes(2, factory, (err, nodes) => {
+          expect(err).to.not.exist()
+
+          ipfsA = nodes[0]
+          ipfsB = nodes[1]
+
+          // Add key to the wantlist for ipfsB
+          ipfsB.block.get(key, () => {})
+
+          waitUntilConnected(ipfsA, ipfsB, done)
+        })
+      })
+    })
+
+    after(function (done) {
+      this.timeout(30 * 1000)
+      common.teardown(done)
+    })
+
+    it('should get the wantlist', (done) => {
+      waitForWantlistKey(ipfsB, key, done)
+    })
+
+    it('should get the wantlist by peer ID for a diffreent node', (done) => {
+      ipfsB.id((err, info) => {
+        expect(err).to.not.exist()
+        waitForWantlistKey(ipfsA, key, { peerId: info.id }, done)
+      })
+    })
+
+    it('should not get the wantlist when offline', function (done) {
+      this.timeout(60 * 1000)
+
+      waterfall([
+        (cb) => createCommon().setup(cb),
+        (factory, cb) => factory.spawnNode(cb),
+        (node, cb) => node.stop((err) => cb(err, node))
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        node.bitswap.wantlist((err) => {
+          expect(err).to.exist()
+          done()
+        })
+      })
+    })
+  })
+}

js/src/index.js

@@ -1,5 +1,6 @@
 'use strict'
 
+exports.bitswap = require('./bitswap')
 exports.block = require('./block')
 exports.bootstrap = require('./bootstrap')
 exports.config = require('./config')