test: stub core in cli tests (#2798)

Our CLI tests test core functionality, most of which is duplicated
by our interface tests, consequently our tests take unnecessarily
long to run as the same code paths are being exercised by multiple
tests during a test run.

This PR refactors the tests to use sinon to stub core methods and
refocusses them on making sure we pass the correct arguments to
our core APIs.

The exceptions to this are where CLI tests run code that is not
part of the core interface API, such as `init` and starting/stopping
daemons.

Author: achingbrain

packages/ipfs/package.json

@@ -177,21 +177,22 @@
     "clear-module": "^4.0.0",
     "cross-env": "^7.0.0",
     "delay": "^4.3.0",
-    "dir-compare": "^1.7.3",
     "execa": "^3.0.0",
     "form-data": "^3.0.0",
     "go-ipfs-dep": "0.4.23-3",
     "hat": "0.0.3",
     "interface-ipfs-core": "^0.132.0",
     "ipfs-interop": "^1.0.0",
     "ipfsd-ctl": "^3.0.0",
+    "it-first": "^1.0.1",
     "ncp": "^2.0.0",
     "p-event": "^4.1.0",
     "p-map": "^3.0.0",
     "qs": "^6.5.2",
     "rimraf": "^3.0.0",
     "sinon": "^8.0.4",
     "stream-to-promise": "^2.2.0",
+    "string-argv": "^0.3.1",
     "temp-write": "^4.0.0"
   },
   "optionalDependencies": {

packages/ipfs/src/cli/bin.js

@@ -17,86 +17,88 @@ process.once('unhandledRejection', (err) => {
 
 const semver = require('semver')
 const pkg = require('../../package.json')
+
 // Check for node version
 if (!semver.satisfies(process.versions.node, pkg.engines.node)) {
   console.error(`Please update your Node.js version to ${pkg.engines.node}`)
   process.exit(1)
 }
 
 const updateNotifier = require('update-notifier')
-const debug = require('debug')('ipfs:cli')
 const { InvalidRepoVersionError } = require('ipfs-repo/src/errors/index')
 const { NotEnabledError } = require('../core/errors')
-const parser = require('./parser')
-
-const commandAlias = require('./command-alias')
 const { print, getIpfs, getRepoPath } = require('./utils')
+const debug = require('debug')('ipfs:cli')
+const cli = require('./')
 
 // Check if an update is available and notify
 const oneWeek = 1000 * 60 * 60 * 24 * 7
 updateNotifier({ pkg, updateCheckInterval: oneWeek }).notify()
 
-// Apply command aliasing (eg `refs local` -> `refs-local`)
-const args = commandAlias(process.argv.slice(2))
-const repoPath = getRepoPath()
+async function main () {
+  let exitCode = 0
+  let ctx = {
+    print,
+    getStdin: () => process.stdin,
+    repoPath: getRepoPath(),
+    cleanup: () => {}
+  }
 
-let ctx = {
-  print,
-  repoPath,
-  cleanup: () => {},
-  getStdin: () => process.stdin
-}
-parser
-  .middleware(async (argv) => {
-    if (!['daemon', 'init'].includes(argv._[0])) {
-      const { ipfs, isDaemon, cleanup } = await getIpfs(argv)
-      ctx = {
-        print,
-        repoPath,
-        ipfs,
-        isDaemon,
-        cleanup,
-        getStdin: ctx.getStdin
+  const command = process.argv.slice(2)
+
+  try {
+    const data = await cli(command, async (argv) => {
+      if (!['daemon', 'init'].includes(command[0])) {
+        const { ipfs, isDaemon, cleanup } = await getIpfs(argv)
+
+        ctx = {
+          ...ctx,
+          ipfs,
+          isDaemon,
+          cleanup
+        }
       }
-    }
 
-    argv.ctx = ctx
-    return argv
-  })
-  .onFinishCommand(async (data) => {
+      argv.ctx = ctx
+
+      return argv
+    })
+
     if (data) {
       print(data)
     }
-
-    await ctx.cleanup()
-  })
-  .fail(async (msg, err, yargs) => {
-    // Handle yargs errors
-    if (msg) {
-      yargs.showHelp()
-      print.error('\n')
-      print.error(`Error: ${msg}`)
+  } catch (err) {
+    if (err.code === InvalidRepoVersionError.code) {
+      err.message = 'Incompatible repo version. Migration needed. Pass --migrate for automatic migration'
     }
 
-    // Handle commands handler errors
-    if (err) {
-      if (err.code === InvalidRepoVersionError.code) {
-        err.message = 'Incompatible repo version. Migration needed. Pass --migrate for automatic migration'
-      }
-
-      if (err.code === NotEnabledError.code) {
-        err.message = `no IPFS repo found in ${getRepoPath()}.\nplease run: 'ipfs init'`
-      }
+    if (err.code === NotEnabledError.code) {
+      err.message = `no IPFS repo found in ${ctx.repoPath}.\nplease run: 'ipfs init'`
+    }
 
-      if (debug.enabled) {
-        debug(err)
-      } else {
-        print.error(err.message)
-      }
+    // Handle yargs errors
+    if (err.code === 'ERR_YARGS') {
+      err.yargs.showHelp()
+      ctx.print.error('\n')
+      ctx.print.error(`Error: ${err.message}`)
+    } else if (debug.enabled) {
+      // Handle commands handler errors
+      debug(err)
+    } else {
+      ctx.print.error(err.message)
     }
 
+    exitCode = 1
+  } finally {
     await ctx.cleanup()
+  }
 
-    process.exit(1)
-  })
-  .parse(args)
+  if (command[0] === 'daemon' && exitCode === 0) {
+    // don't shut down the daemon process
+    return
+  }
+
+  process.exit(exitCode)
+}
+
+main()

packages/ipfs/src/cli/commands/add.js

@@ -187,7 +187,8 @@ module.exports = {
       preload: argv.preload,
       nonatomic: argv.nonatomic,
       fileImportConcurrency: argv.fileImportConcurrency,
-      blockWriteConcurrency: argv.blockWriteConcurrency
+      blockWriteConcurrency: argv.blockWriteConcurrency,
+      progress: () => {}
     }
 
     if (options.enableShardingExperiment && isDaemon) {
@@ -203,9 +204,9 @@ module.exports = {
 
     if (argv.progress && argv.file) {
       const totalBytes = await getTotalBytes(argv.file)
-      bar = createProgressBar(totalBytes)
+      bar = createProgressBar(totalBytes, print)
 
-      if (process.stdout.isTTY) {
+      if (print.isTTY) {
         // bar.interrupt uses clearLine and cursorTo methods that are only on TTYs
         log = bar.interrupt.bind(bar)
       }

packages/ipfs/src/cli/commands/cat.js

@@ -19,10 +19,10 @@ module.exports = {
   },
 
   async handler ({ ctx, ipfsPath, offset, length }) {
-    const { ipfs } = ctx
+    const { ipfs, print } = ctx
 
     for await (const buf of ipfs.cat(ipfsPath, { offset, length })) {
-      process.stdout.write(buf)
+      print.write(buf)
     }
   }
 }

packages/ipfs/src/cli/commands/config/profile/apply.js

@@ -10,7 +10,8 @@ module.exports = {
   builder: {
     'dry-run': {
       type: 'boolean',
-      describe: 'print difference between the current config and the config that would be generated.'
+      describe: 'print difference between the current config and the config that would be generated.',
+      default: false
     }
   },
 

packages/ipfs/src/cli/commands/id.js

@@ -8,13 +8,27 @@ module.exports = {
   builder: {
     format: {
       alias: 'f',
-      type: 'string'
+      type: 'string',
+      describe: 'Print Node ID info in the given format. Allowed tokens: <id> <aver> <pver> <pubkey> <addrs>'
     }
   },
 
-  async handler ({ ctx }) {
-    const { ipfs } = ctx
+  async handler ({ ctx, format }) {
+    const { ipfs, print } = ctx
     const id = await ipfs.id()
-    return JSON.stringify(id, '', 2)
+
+    if (format) {
+      print(format
+        .replace('<id>', id.id)
+        .replace('<aver>', id.agentVersion)
+        .replace('<pver>', id.protocolVersion)
+        .replace('<pubkey>', id.publicKey)
+        .replace('<addrs>', (id.addresses || []).map(addr => addr.toString()).join('\n'))
+      )
+
+      return
+    }
+
+    print(JSON.stringify(id, '', 2))
   }
 }

packages/ipfs/src/cli/commands/name/publish.js

@@ -31,9 +31,9 @@ module.exports = {
     }
   },
 
-  async handler (argv) {
-    const { ipfs, print } = argv.ctx
-    const result = await ipfs.name.publish(argv.ipfsPath, argv)
+  async handler ({ ctx, ipfsPath, resolve, lifetime, key, ttl }) {
+    const { ipfs, print } = ctx
+    const result = await ipfs.name.publish(ipfsPath, { resolve, lifetime, key, ttl })
     print(`Published to ${result.name}: ${result.value}`)
   }
 }

packages/ipfs/src/cli/index.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const parser = require('./parser')
+const commandAlias = require('./command-alias')
+const errCode = require('err-code')
+
+module.exports = (command, ctxMiddleware) => {
+  // Apply command aliasing (eg `refs local` -> `refs-local`)
+  command = commandAlias(command)
+
+  return new Promise((resolve, reject) => {
+    try {
+      parser
+        .middleware(ctxMiddleware)
+        .onFinishCommand((data) => {
+          resolve(data)
+        })
+        .fail((msg, err, yargs) => {
+          // Handle yargs errors
+          if (msg) {
+            return reject(errCode(new Error(msg), 'ERR_YARGS', { yargs }))
+          }
+
+          reject(err)
+        })
+        .parse(command)
+    } catch (err) {
+      return reject(err)
+    }
+  })
+}

packages/ipfs/src/cli/parser.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const yargs = require('yargs')
+const yargs = require('yargs/yargs')(process.argv.slice(2))
 const mfs = require('ipfs-mfs/cli')
 const utils = require('./utils')
 

packages/ipfs/src/cli/utils.js

@@ -26,34 +26,45 @@ const isDaemonOn = () => {
 let visible = true
 const disablePrinting = () => { visible = false }
 
-const print = (msg, newline, isError = false) => {
-  if (newline === undefined) {
-    newline = true
-  }
-
+const print = (msg, includeNewline = true, isError = false) => {
   if (visible) {
     if (msg === undefined) {
       msg = ''
     }
-    msg = newline ? msg + '\n' : msg
+    msg = includeNewline ? msg + '\n' : msg
     const outStream = isError ? process.stderr : process.stdout
     outStream.write(msg)
   }
 }
 
+print.clearLine = () => {
+  return process.stdout.clearLine()
+}
+
+print.cursorTo = (pos) => {
+  process.stdout.cursorTo(pos)
+}
+
+print.write = (data) => {
+  process.stdout.write(data)
+}
+
 print.error = (msg, newline) => {
   print(msg, newline, true)
 }
 
-const createProgressBar = (totalBytes) => {
+// used by ipfs.add to interrupt the progress bar
+print.isTTY = process.stdout.isTTY
+
+const createProgressBar = (totalBytes, output) => {
   const total = byteman(totalBytes, 2, 'MB')
   const barFormat = `:progress / ${total} [:bar] :percent :etas`
 
   // 16 MB / 34 MB [===========             ] 48% 5.8s //
   return new Progress(barFormat, {
     incomplete: ' ',
     clear: true,
-    stream: process.stdout,
+    stream: output,
     total: totalBytes
   })
 }