Make it possible to use a running IPFS daemon for tests.

Author: haadcode

gulpfile.js

@@ -5,9 +5,9 @@ const gulp = require('gulp')
 require('./test/setup/spawn-daemons')
 require('./test/factory/factory-tasks')
 
-gulp.task('test:node:before', ['daemons:start', 'factory:start'])
-gulp.task('test:node:after', ['daemons:stop', 'factory:stop'])
-gulp.task('test:browser:before', ['daemons:start', 'factory:start'])
-gulp.task('test:browser:after', ['daemons:stop', 'factory:stop'])
+gulp.task('test:node:before', ['factory:start'])
+gulp.task('test:node:after', ['factory:stop'])
+gulp.task('test:browser:before', ['factory:start'])
+gulp.task('test:browser:after', ['factory:stop'])
 
 require('aegir/gulp')(gulp)

test/factory/daemon-spawner.js

@@ -13,7 +13,7 @@ function Factory () {
 
   const nodes = []
 
-  this.spawnNode = (repoPath, config, callback) => {
+  this.spawnNode = (repoPath, config, useLocalDaemon, callback) => {
     if (typeof repoPath === 'function') {
       callback = repoPath
       repoPath = undefined
@@ -35,13 +35,23 @@ function Factory () {
     // This will come once the new ipfsd-ctl is
     // complete: https://github.com/ipfs/js-ipfsd-ctl/pull/89
 
-    spawnEphemeralNode((err, node) => {
-      if (err) {
-        return callback(err)
-      }
-      nodes.push(node)
-      callback(null, node.apiAddr)
-    })
+    if (useLocalDaemon) {
+      spawnLocalNode((err, node) => {
+        if (err) {
+          return callback(err)
+        }
+        nodes.push(node)
+        callback(null, node.apiAddr)
+      })
+    } else {
+      spawnEphemeralNode((err, node) => {
+        if (err) {
+          return callback(err)
+        }
+        nodes.push(node)
+        callback(null, node.apiAddr)
+      })
+    }
   }
 
   this.dismantle = function (callback) {
@@ -52,6 +62,22 @@ function Factory () {
   }
 }
 
+function spawnLocalNode (callback) {
+  ipfsd.local((err, node) => {
+    if (err) {
+      return callback(err)
+    }
+
+    node.startDaemon((err, ipfs) => {
+      if (err) {
+        return callback(err)
+      }
+
+      callback(null, node)
+    })
+  })
+}
+
 function spawnEphemeralNode (callback) {
   ipfsd.disposable((err, node) => {
     if (err) {

test/factory/factory-client.js

@@ -17,7 +17,7 @@ function Factory () {
   let sioConnected = false
   let ioC
 
-  this.spawnNode = (repoPath, config, callback) => {
+  this.spawnNode = (repoPath, config, useLocalDaemon, callback) => {
     if (typeof repoPath === 'function') {
       callback = repoPath
       repoPath = undefined
@@ -26,6 +26,10 @@ function Factory () {
       callback = config
       config = undefined
     }
+    if (typeof useLocalDaemon === 'function') {
+      callback = useLocalDaemon
+      useLocalDaemon = false
+    }
 
     if (sioConnected) {
       spawnNode()
@@ -43,7 +47,7 @@ function Factory () {
         const ipfs = ipfsAPI(apiAddr)
         callback(null, ipfs)
       })
-      ioC.emit('fs-spawn-node', repoPath, config)
+      ioC.emit('fs-spawn-node', repoPath, config, useLocalDaemon)
     }
   }
 

test/factory/factory-server-routes.js

@@ -14,8 +14,8 @@ module.exports = (http) => {
     socket.on('fs-dismantle', dismantle.bind(socket))
   }
 
-  function spawnNode (repoPath, config) {
-    ds.spawnNode(repoPath, config, (err, apiAddr) => {
+  function spawnNode (repoPath, config, useLocalDaemon) {
+    ds.spawnNode(repoPath, config, useLocalDaemon, (err, apiAddr) => {
       if (err) {
         throw err
       }

test/setup/setup-ipfs-api-clients.js

@@ -1,77 +1,77 @@
-/* eslint-env mocha */
-'use strict'
+// /* eslint-env mocha */
+// 'use strict'
 
-const ipfsAPI = require('./../../src/index.js')
-const apiAddrs = require('./tmp-disposable-nodes-addrs.json')
+// // const ipfsAPI = require('./../../src/index.js')
+// // const apiAddrs = require('./tmp-disposable-nodes-addrs.json')
 
-// a, b, c
-global.apiClients = {}
+// // a, b, c
+// global.apiClients = {}
 
-const addrs = {}
+// const addrs = {}
 
-function connectNodes (done) {
-  let counter = 0
+// // function connectNodes (done) {
+// //   let counter = 0
 
-  function collectAddr (key, cb) {
-    global.apiClients[key].id((err, id) => {
-      if (err) {
-        throw err
-      }
-      // note to self: HTTP API port !== Node port
-      addrs[key] = id.addresses[0]
-      cb()
-    })
-  }
+// //   function collectAddr (key, cb) {
+// //     global.apiClients[key].id((err, id) => {
+// //       if (err) {
+// //         throw err
+// //       }
+// //       // note to self: HTTP API port !== Node port
+// //       addrs[key] = id.addresses[0]
+// //       cb()
+// //     })
+// //   }
 
-  function dial () {
-    global.apiClients.a.swarm.connect(addrs.b, (err, res) => {
-      if (err) {
-        throw err
-      }
-      global.apiClients.a.swarm.connect(addrs.c, (err) => {
-        if (err) {
-          throw err
-        }
-        done()
-      })
-    })
-  }
+// //   function dial () {
+// //     global.apiClients.a.swarm.connect(addrs.b, (err, res) => {
+// //       if (err) {
+// //         throw err
+// //       }
+// //       global.apiClients.a.swarm.connect(addrs.c, (err) => {
+// //         if (err) {
+// //           throw err
+// //         }
+// //         done()
+// //       })
+// //     })
+// //   }
 
-  function finish () {
-    counter++
-    if (counter === 2) {
-      dial()
-    }
-  }
+// //   function finish () {
+// //     counter++
+// //     if (counter === 2) {
+// //       dial()
+// //     }
+// //   }
 
-  collectAddr('b', finish)
-  collectAddr('c', finish)
-}
+// //   collectAddr('b', finish)
+// //   collectAddr('c', finish)
+// // }
 
-function disconnectNodes (done) {
-  global.apiClients.a.swarm.disconnect(addrs.b, (err) => {
-    if (err) {
-      throw err
-    }
-    global.apiClients.a.swarm.disconnect(addrs.c, (err) => {
-      if (err) {
-        throw err
-      }
-      done()
-    })
-  })
-}
+// // function disconnectNodes (done) {
+// //   global.apiClients.a.swarm.disconnect(addrs.b, (err) => {
+// //     if (err) {
+// //       throw err
+// //     }
+// //     global.apiClients.a.swarm.disconnect(addrs.c, (err) => {
+// //       if (err) {
+// //         throw err
+// //       }
+// //       done()
+// //     })
+// //   })
+// // }
 
-before(function (done) {
-  this.timeout(20000)
+// // before(function (done) {
+// //   this.timeout(20000)
 
-  Object.keys(apiAddrs).forEach((key) => {
-    global.apiClients[key] = ipfsAPI(apiAddrs[key])
-  })
+// //   Object.keys(apiAddrs).forEach((key) => {
+// //     global.apiClients[key] = ipfsAPI(apiAddrs[key])
+// //   })
 
-  connectNodes(done)
-})
+// //   connectNodes(done)
+// // })
 
-after(function (done) {
-  disconnectNodes(done)
-})
+// // after(function (done) {
+// //   disconnectNodes(done)
+// // })