refactor bitswap tests

Author: daviddias

test/core/bitswap.spec.js

@@ -34,6 +34,44 @@ function makeBlock (callback) {
   })
 }
 
+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)
+}
+
+function addNode (num, inProcNode, callback) {
+  num = leftPad(num, 3, 0)
+
+  const apiUrl = `/ip4/127.0.0.1/tcp/31${num}`
+  const remoteNode = new API(apiUrl)
+
+  connectNodes(remoteNode, inProcNode, (err) => callback(err, remoteNode))
+}
+
 describe('bitswap', function () {
   this.timeout(80 * 1000)
 
@@ -42,7 +80,7 @@ describe('bitswap', function () {
   beforeEach(function (done) {
     this.timeout(60 * 1000)
 
-    let config = {
+    let options = {
       repo: createTempRepo(),
       config: {
         Addresses: {
@@ -58,7 +96,7 @@ describe('bitswap', function () {
     }
 
     if (isNode) {
-      config = Object.assign(config, {
+      options = Object.assign(options, {
         config: {
           Addresses: {
             Swarm: ['/ip4/127.0.0.1/tcp/0']
@@ -67,150 +105,110 @@ describe('bitswap', function () {
       })
     }
 
-    inProcNode = new IPFS(config)
+    inProcNode = new IPFS(options)
     inProcNode.on('start', () => done())
   })
 
   afterEach(function (done) {
-    this.timeout(30 * 1000)
-
+    this.timeout(60 * 1000)
     inProcNode.stop(() => done())
   })
 
-  describe('connections', () => {
-    function wire (targetNode, dialerNode, done) {
-      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]
+  describe('transfer a block between', () => {
+    it('2 peers', function (done) {
+      this.timeout(40 * 1000)
 
-        if (!addr) {
-          // Note: the browser doesn't have a websockets listening addr
-          return done()
+      let remoteNode
+      let block
+      waterfall([
+        (cb) => parallel([
+          (cb) => makeBlock(cb),
+          (cb) => addNode(13, 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()
         }
-
-        const targetAddr = addr
-          .encapsulate(multiaddr(`/ipfs/${identity.id}`)).toString()
-          .replace('0.0.0.0', '127.0.0.1')
-
-        dialerNode.swarm.connect(targetAddr, done)
-      })
-    }
-
-    function connectNodes (remoteNode, ipn, done) {
-      series([
-        (cb) => wire(remoteNode, ipn, cb),
-        // need timeout so we wait for identify to happen.
-        // This call is just to ensure identify happened
-        (cb) => setTimeout(() => wire(ipn, remoteNode, cb), 300)
       ], done)
-    }
-
-    function addNode (num, done) {
-      num = leftPad(num, 3, 0)
+    })
 
-      const apiUrl = `/ip4/127.0.0.1/tcp/31${num}`
-      const remoteNode = new API(apiUrl)
+    it('3 peers', function (done) {
+      this.timeout(60 * 1000)
 
-      connectNodes(remoteNode, inProcNode, (err) => done(err, remoteNode))
-    }
+      let blocks
+      const remoteNodes = []
 
-    describe('fetches a remote block', () => {
-      it('2 peers', function (done) {
-        this.timeout(10 * 1000)
-
-        let remoteNode
-        let block
-        waterfall([
-          (cb) => parallel([
-            (cb) => makeBlock(cb),
-            (cb) => addNode(13, 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()
+      series([
+        (cb) => parallel(_.range(6).map((i) => makeBlock), (err, _blocks) => {
+          expect(err).to.not.exist()
+          blocks = _blocks
+          cb()
+        }),
+        (cb) => addNode(8, inProcNode, (err, _ipfs) => {
+          remoteNodes.push(_ipfs)
+          cb(err)
+        }),
+        (cb) => addNode(7, 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()
+            })
           }
-        ], done)
-      })
 
-      it('3 peers', function (done) {
-        this.timeout(30 * 1000)
-
-        let blocks
-        const remoteNodes = []
-
-        series([
-          (cb) => parallel(_.range(6).map((i) => makeBlock), (err, _blocks) => {
-            expect(err).to.not.exist()
-            blocks = _blocks
-            cb()
-          }),
-          (cb) => addNode(8, (err, _ipfs) => {
-            remoteNodes.push(_ipfs)
-            cb(err)
-          }),
-          (cb) => addNode(7, (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()
-              })
-            }
-
-            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)
-      })
+          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)
     })
+  })
 
-    describe('fetches a remote file', () => {
-      it('2 peers', (done) => {
-        const file = Buffer.from(`I love IPFS <3 ${Math.random()}`)
-
-        waterfall([
-          // 0. Start node
-          (cb) => addNode(12, cb),
-          // 1. Add file to tmp instance
-          (remote, cb) => {
-            remote.files.add([{path: 'awesome.txt', content: file}], cb)
-          },
-          // 2. Request file from local instance
-          (filesAdded, cb) => inProcNode.files.cat(filesAdded[0].hash, cb)
-        ], (err, data) => {
-          expect(err).to.not.exist()
-          expect(data).to.eql(file)
-          done()
-        })
+  describe('transfer a file between', () => {
+    it('2 peers', (done) => {
+      // TODO make this test more interesting (10Mb file)
+      const file = Buffer.from(`I love IPFS <3 ${Math.random()}`)
+
+      waterfall([
+        // 0. Start node
+        (cb) => addNode(12, inProcNode, cb),
+        // 1. Add file to tmp instance
+        (remote, cb) => {
+          remote.files.add([{path: 'awesome.txt', content: file}], cb)
+        },
+        // 2. Request file from local instance
+        (filesAdded, cb) => inProcNode.files.cat(filesAdded[0].hash, cb)
+      ], (err, data) => {
+        expect(err).to.not.exist()
+        expect(data).to.eql(file)
+        done()
       })
     })
   })
 
-  describe('bitswap API', () => {
+  describe('api', () => {
     let node
 
     before(function (done) {
@@ -243,8 +241,7 @@ describe('bitswap', function () {
       })
 
       it('throws if offline', () => {
-        expect(() => node.bitswap.unwant('my key'))
-          .to.throw(/online/)
+        expect(() => node.bitswap.unwant('my key')).to.throw(/online/)
       })
     })