testen

#!/usr/bin/env node
'use strict'

/**
 * Module dependencies
 */
const fs = require('fs')
const minimist = require('minimist')
const update = require('update-notifier')
const chalk = require('chalk')
const pathExists = require('path-exists')
const figures = require('figures')
const log = require('log-update')
const textTable = require('text-table')
const co = require('co')
const exec = require('then-exec')
const arrayUnique = require('array-unique')
const Hinata = require('hinata')
const travisOrCircle = require('travis-or-circle')
const indento = require('indento')
const series = require('promise.series')
const stringWidth = require('string-width')
const pkg = require('./package')
const presetVersions = require('./lib/preset-versions')

const table = result => textTable(result, {stringLength: stringWidth})

const spin = new Hinata({char: '●', text: '  ', prepend: true, spacing: 1})

update({pkg}).notify()

const cli = minimist(process.argv.slice(2), {
  '--': true,
  'alias': {
    s: 'sequence',
    n: 'node',
    h: 'help',
    v: 'version',
    V: 'verbose'
  },
  'string': ['node']
})
/**
 * Print help
 */
if (cli.help) {
  console.log([
    '',
    'Usage:',
    '',
    '  --system:             Use current node version',
    '  -n/--node [version]:  Add a node version to test',
    '  -s, --sequence:       Run tests in sequence',
    '  -- [command]:         The test command you expect',
    '  -V/--verbose:         Always output everything',
    '                          ~ example: there are `console.log` in test',
    ''
  ].join('\n'))
  process.exit()
}

/**
 * Print version
 */
if (cli.version) {
  console.log(pkg.version)
  process.exit()
}

/**
 * Local package.json
 */
let localPkg = {}
if (pathExists.sync(process.cwd() + '/package.json')) {
  localPkg = require(process.cwd() + '/package.json')
}

/**
 * Test script
 */
let testScript = cli['--'].join(' ')
if (!testScript) {
  if (localPkg.testen && localPkg.testen.test) {
    testScript = localPkg.testen.test
  } else {
    testScript = 'npm test'
  }
}

/**
 * Get status form an array of errors
 */
function getStatus(res) {
  let status = 0
  res.every(r => {
    const e = r.error
    if (!e) {
      return false
    }
    if (e.code !== undefined && e.code !== 0) {
      status = e.code
      return false
    }
    return true
  })
  return status
}

/**
 * Compare two version number
 * @param  {string} left
 * @param  {string} right
 * @return {number} 1/-1/0
 */
function versionCompare(left, right) {
  if (typeof left + typeof right !== 'stringstring') {
    throw new TypeError('Expect version number to be string')
  }

  const a = left.split('.')
  const b = right.split('.')
  const len = Math.max(a.length, b.length)

  for (let i = 0; i < len; i++) {
    if ((a[i] && !b[i] && parseInt(a[i]) > 0) || (parseInt(a[i]) > parseInt(b[i]))) {
      return 1
    } else if ((b[i] && !a[i] && parseInt(b[i]) > 0) || (parseInt(a[i]) < parseInt(b[i]))) {
      return -1
    }
  }

  return 0
}

co(function* main () {
  /**
   * Get node versions from cli or .yml
   * If nothing got then read from package.json
   * It still nothing, use default node verison or preset versions
   * Finally sort and arrayUnique
   */
  let nodeVersions = []
  if (cli.system) {
    const defaultNodeVersion = yield exec('node -v')
    nodeVersions = [defaultNodeVersion.stdout.trim().substr(1)]
  } else if (cli.node === undefined) {
    nodeVersions = travisOrCircle() || []
  }
  nodeVersions = nodeVersions.concat(cli.node || [])
  if ((!nodeVersions || nodeVersions.length === 0) && typeof nodeVersions !== 'number') {
    const pkgNodeVersion = localPkg.testen && localPkg.testen.node
    if (pkgNodeVersion && pkgNodeVersion.length > 0) {
      nodeVersions = pkgNodeVersion
    } else {
      nodeVersions = presetVersions
    }
  }
  if (!Array.isArray(nodeVersions)) {
    nodeVersions = [nodeVersions]
  }
  nodeVersions = nodeVersions.map(v => String(v))
  nodeVersions = arrayUnique(nodeVersions)
  nodeVersions.sort((a, b) => versionCompare(a, b))

  const spinLength = nodeVersions.length
  spin.length = spinLength
  spin.start()

  /**
   * Generate initial result and log as table
   */
  const result = nodeVersions.map(v => {
    return ['  ' + chalk.dim(figures.circle), v, chalk.dim('pending'), '']
  })
  log('\n' + table(result) + '\n')

  /**
   * Execute test
   */
  let msg = []
  const execTest = co.wrap(function* (command, index, version) {
    result[index][2] = 'running'
    log('\n' + table(result) + '\n')
    const startTime = Date.now()
    const cmd = yield exec(command)
    const endTime = Date.now()
    result[index] = [
      '  ' + (cmd.error ? chalk.red(figures.cross) : chalk.green(figures.tick)),
      nodeVersions[index],
      cmd.error ? chalk.red('failed') : chalk.green('success'),
      chalk.dim(`${endTime - startTime}ms`)
    ]
    if (cmd && (cmd.error || cli.verbose)) {
      let output = cmd.stdout.toString().split('\n')
      const statusColor = cmd.error ? 'red' : 'green'
      output[0] = chalk.bold[statusColor](output[0] || chalk.red(`Node v${version} is not yet installed`))
      if (!output[1] && !cmd.error) {
        output[1] = 'no output\n'
      }
      output = output.join('\n')
      msg[index] = `${output.trim()}\n${cmd.error ? `${cmd.error.message.trim()}` : ''}`
    }
    let heading = `${msg.join('\n\n')}\n`
    if (heading.trim()) {
      heading += '\n'
    }
    log(heading + table(result) + '\n')
    return cmd
  })

  /**
   * Running test for each version of node
   */
  const handler = (v, index) => {
    return execTest(`. ~/.nvm/nvm.sh && nvm exec ${v} ${testScript}`, index, v)
  }
  const tasks = cli.sequence ? series(nodeVersions.map((v, index) => {
    return () => handler(v, index)
  })) : Promise.all(nodeVersions.map(handler))

  yield tasks

  spin.stop()
}).catch(e => {
  log.clear()
  console.log(e.stack)
  spin.stop()
})