pulsar/script/test

#!/usr/bin/env node

'use strict'

require('colors')
const argv = require('yargs')
  .option('core-main', {
    describe: 'Run core main process tests',
    boolean: true,
    default: false
  })
  .option('skip-main', {
    describe: 'Skip main process tests if they would otherwise run on your platform',
    boolean: true,
    default: false,
    conflicts: 'core-main'
  })
  .option('core-renderer', {
    describe: 'Run core renderer process tests',
    boolean: true,
    default: false
  })
  .option('core-benchmark', {
    describe: 'Run core benchmarks',
    boolean: true,
    default: false
  })
  .option('package', {
    describe: 'Run bundled package specs',
    boolean: true,
    default: false
  })
  .help()
  .argv

const assert = require('assert')
const async = require('async')
const childProcess = require('child_process')
const fs = require('fs-extra')
const glob = require('glob')
const path = require('path')

const CONFIG = require('./config')
const backupNodeModules = require('./lib/backup-node-modules')
const runApmInstall = require('./lib/run-apm-install')

const resourcePath = CONFIG.repositoryRootPath
let executablePath
if (process.platform === 'darwin') {
  const executablePaths = glob.sync(path.join(CONFIG.buildOutputPath, '*.app'))
  assert(executablePaths.length === 1, `More than one application to run tests against was found. ${executablePaths.join(',')}`)
  executablePath = path.join(executablePaths[0], 'Contents', 'MacOS', path.basename(executablePaths[0], '.app'))
} else if (process.platform === 'linux') {
  const executablePaths = glob.sync(path.join(CONFIG.buildOutputPath, 'atom-*', 'atom'))
  assert(executablePaths.length === 1, `More than one application to run tests against was found. ${executablePaths.join(',')}`)
  executablePath = executablePaths[0]
} else if (process.platform === 'win32') {
  const executablePaths = glob.sync(path.join(CONFIG.buildOutputPath, '**', 'atom.exe'))
  assert(executablePaths.length === 1, `More than one application to run tests against was found. ${executablePaths.join(',')}`)
  executablePath = executablePaths[0]
} else {
  throw new Error('Running tests on this platform is not supported.')
}

function prepareEnv (suiteName) {
  const env = Object.assign({}, process.env)

  if (process.env.TEST_JUNIT_XML_ROOT) {
    // Tell Jasmine to output this suite's results as a JUnit XML file to a subdirectory of the root, so that a
    // CI system can interpret it.
    const fileName = suiteName + '.xml'
    const outputPath = path.join(process.env.TEST_JUNIT_XML_ROOT, fileName)
    env.TEST_JUNIT_XML_PATH = outputPath
  }

  return env
}

function runCoreMainProcessTests (callback) {
  const testPath = path.join(CONFIG.repositoryRootPath, 'spec', 'main-process')
  const testArguments = [
    '--resource-path', resourcePath,
    '--test', '--main-process', testPath
  ]
  const testEnv = Object.assign({}, prepareEnv('core-main-process'), {ATOM_GITHUB_INLINE_GIT_EXEC: 'true'})

  console.log('Executing core main process tests'.bold.green)
  const cp = childProcess.spawn(executablePath, testArguments, {stdio: 'inherit', env: testEnv})
  cp.on('error', error => { callback(error) })
  cp.on('close', exitCode => { callback(null, {exitCode, step: 'core-main-process'}) })
}

function runCoreRenderProcessTests (callback) {
  const testPath = path.join(CONFIG.repositoryRootPath, 'spec')
  const testArguments = [
    '--resource-path', resourcePath,
    '--test', testPath
  ]
  const testEnv = prepareEnv('core-render-process')

  console.log('Executing core render process tests'.bold.green)
  const cp = childProcess.spawn(executablePath, testArguments, {stdio: 'inherit', env: testEnv})
  cp.on('error', error => { callback(error) })
  cp.on('close', exitCode => { callback(null, {exitCode, step: 'core-render-process'}) })
}

// Build an array of functions, each running tests for a different bundled package
const packageTestSuites = []
for (let packageName in CONFIG.appMetadata.packageDependencies) {
  if (process.env.ATOM_PACKAGES_TO_TEST) {
    const packagesToTest = process.env.ATOM_PACKAGES_TO_TEST.split(',').map(pkg => pkg.trim())
    if (!packagesToTest.includes(packageName)) continue
  }

  const repositoryPackagePath = path.join(CONFIG.repositoryRootPath, 'node_modules', packageName)
  const testSubdir = ['spec', 'test'].find(subdir => fs.existsSync(path.join(repositoryPackagePath, subdir)))

  if (!testSubdir) {
    packageTestSuites.push(function (callback) {
      console.log(`Skipping tests for ${packageName} because no test folder was found`.bold.yellow)
      callback(null, {exitCode: 0, step: `package-${packageName}`})
    })
    continue
  }

  const testFolder = path.join(repositoryPackagePath, testSubdir)

  packageTestSuites.push(function (callback) {
    const testArguments = [
      '--resource-path', resourcePath,
      '--test', testFolder
    ]
    const testEnv = prepareEnv(`bundled-package-${packageName}`)

    const pkgJsonPath = path.join(repositoryPackagePath, 'package.json')
    const nodeModulesPath = path.join(repositoryPackagePath, 'node_modules')
    let finalize = () => null
    if (require(pkgJsonPath).atomTestRunner) {
      console.log(`Installing test runner dependencies for ${packageName}`.bold.green)
      if (fs.existsSync(nodeModulesPath)) {
        const backup = backupNodeModules(repositoryPackagePath)
        finalize = backup.restore
      } else {
        finalize = () => fs.removeSync(nodeModulesPath)
      }
      runApmInstall(repositoryPackagePath)
      console.log(`Executing ${packageName} tests`.green)
    } else {
      console.log(`Executing ${packageName} tests`.bold.green)
    }
    const cp = childProcess.spawn(executablePath, testArguments, {env: testEnv})
    let stderrOutput = ''
    cp.stderr.on('data', data => { stderrOutput += data })
    cp.stdout.on('data', data => { stderrOutput += data })
    cp.on('error', error => {
      finalize()
      callback(error)
    })
    cp.on('close', exitCode => {
      if (exitCode !== 0) {
        console.log(`Package tests failed for ${packageName}:`.red)
        console.log(stderrOutput)
      }
      finalize()
      callback(null, {exitCode, step: `package-${packageName}`})
    })
  })
}

function runBenchmarkTests (callback) {
  const benchmarksPath = path.join(CONFIG.repositoryRootPath, 'benchmarks')
  const testArguments = ['--benchmark-test', benchmarksPath]
  const testEnv = prepareEnv('benchmark')

  console.log('Executing benchmark tests'.bold.green)
  const cp = childProcess.spawn(executablePath, testArguments, {stdio: 'inherit', env: testEnv})
  cp.on('error', error => { callback(error) })
  cp.on('close', exitCode => { callback(null, {exitCode, step: 'core-benchmarks'}) })
}

let testSuitesToRun = requestedTestSuites() || testSuitesForPlatform(process.platform)

function requestedTestSuites () {
  const suites = []
  if (argv.coreMain) {
    suites.push(runCoreMainProcessTests)
  }
  if (argv.coreRenderer) {
    suites.push(runCoreRenderProcessTests)
  }
  if (argv.coreBenchmark) {
    suites.push(runBenchmarkTests)
  }
  if (argv.package) {
    suites.push(...packageTestSuites)
  }
  return suites.length > 0 ? suites : null
}

function testSuitesForPlatform (platform) {
  let suites = []
  switch (platform) {
    case 'darwin':
      if (process.env.ATOM_RUN_CORE_TESTS === 'true') {
        suites = [runCoreMainProcessTests, runCoreRenderProcessTests, runBenchmarkTests]
      } else if (process.env.ATOM_RUN_PACKAGE_TESTS === 'true') {
        suites = packageTestSuites
      } else {
        suites = [runCoreMainProcessTests, runCoreRenderProcessTests, runBenchmarkTests].concat(packageTestSuites)
      }
      break
    case 'win32':
      suites = (process.arch === 'x64') ? [runCoreMainProcessTests, runCoreRenderProcessTests] : [runCoreMainProcessTests]
      break
    case 'linux':
      suites = [runCoreMainProcessTests]
      break
    default:
      console.log(`Unrecognized platform: ${platform}`)
  }

  if (argv.skipMainProcessTests) {
    suites = suites.filter(suite => suite !== runCoreMainProcessTests)
  }

  return suites
}

async.series(testSuitesToRun, function (err, results) {
  if (err) {
    console.error(err)
    process.exit(1)
  } else {
    const failedSteps = results.filter(({exitCode}) => exitCode !== 0)

    for (const {step} of failedSteps) {
      console.error(`Error! The '${step}' test step finished with a non-zero exit code`)
    }

    process.exit(failedSteps.length === 0 ? 0 : 1)
  }
})