adding tests libs for runing an ember server and tear it down

Author: kiwiupover

test-packages/basic-app/test/simple-test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const RSVP = require('rsvp');
+const request = RSVP.denodeify(require('request'));
+const expect = require('chai').use(require('chai-string')).expect;
+const { startServer, stopServer } = require('../../test-libs/index');
+
+describe.only('simple acceptance', function() {
+  this.timeout(5000);
+
+  before(function() {
+    return startServer({
+      command: 'serve'
+    });
+
+  });
+
+  after(function() {
+    return stopServer();
+  });
+
+  it('/ HTML contents', async () => {
+    const response = await request({
+      url: 'http://localhost:49741/',
+      headers: {
+        'Accept': 'text/html'
+      }
+    })
+
+    expect(response.statusCode).to.equal(200);
+    expect(response.headers["content-type"]).to.equalIgnoreCase("text/html; charset=utf-8");
+    expect(response.body).to.contain("Basic fastboot ember app");
+  });
+});

test-packages/test-libs/debug.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const debug = require('debug')('ember-cli-fastboot');
+
+module.exports = debug;

test-packages/test-libs/index.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const runServer = require('./run-server');
+const killCliProcess = require('./kill-cli-process');
+
+let server;
+let longRunningServerPromise;
+
+const startServer = function(options) {
+  return runServer(options)
+    .then(result => {
+      server = result.server;
+      longRunningServerPromise = result.longRunningServerPromise;
+    });
+};
+
+const stopServer = function() {
+  if (!server) {
+    throw new Error('You must call `startServer()` before calling `stopServer()`.');
+  }
+
+  killCliProcess(server);
+
+  return longRunningServerPromise.catch(() => {
+    server = null;
+  });
+};
+
+module.exports = {
+  startServer,
+  stopServer,
+}

test-packages/test-libs/kill-cli-process.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function(childProcess) {
+  if (process.platform === 'win32') {
+    childProcess.send({ kill: true });
+  } else {
+    childProcess.kill('SIGINT');
+  }
+};

test-packages/test-libs/log-on-failure.js

@@ -0,0 +1,29 @@
+/* global beforeEach, afterEach */
+'use strict';
+
+let logSink = [];
+
+if (typeof beforeEach !== 'undefined') {
+  beforeEach(function() {
+    logSink = [];
+  });
+}
+
+if (typeof afterEach !== 'undefined') {
+  afterEach(function() {
+    if (this.currentTest.state !== 'passed') {
+      // It would be preferable to attach the log output to the error object
+      // (this.currentTest.err) and have Mocha report it somehow, so that the
+      // error message and log output show up in the same place. This doesn't
+      // seem to be possible though.
+      console.log(logSink.join('\n')); // eslint-disable-line no-console
+    }
+    logSink = [];
+  });
+}
+
+function logOnFailure(s) {
+  logSink.push(s);
+}
+
+module.exports = logOnFailure;

test-packages/test-libs/run-command.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const denodeify      = require('denodeify');
+const chalk          = require('chalk');
+const childProcess   = require('child_process');
+const spawn          = childProcess.spawn;
+const defaults       = require('lodash/defaults');
+const killCliProcess = require('./kill-cli-process');
+const debug          = require('./debug');
+const logOnFailure   = require('./log-on-failure');
+const exec           = denodeify(childProcess.exec);
+
+const isWindows = process.platform === 'win32';
+
+module.exports = function run(/* command, args, options */) {
+  let command = arguments[0];
+  let args = Array.prototype.slice.call(arguments, 1);
+  let options = {};
+
+  if (typeof args[args.length - 1] === 'object') {
+    options = args.pop();
+  }
+
+  debug('running command=' + command + '; args=' + args + '; cwd=' + process.cwd());
+
+  if (isWindows && (command === 'npm' || command === 'bower')) {
+    return exec(command + ' ' + args.join(' '));
+  }
+
+  options = defaults(options, {
+
+    onOutput(string) {
+      options.log(string);
+    },
+
+    onError(string) {
+      options.log(chalk.red(string));
+    },
+
+    log(string) {
+      debug(string);
+
+      logOnFailure(string);
+    }
+  });
+
+  return new Promise((resolve, reject) => {
+    let opts = {};
+    if (isWindows) {
+      args = ['"' + command + '"'].concat(args);
+      command = 'node';
+      opts.windowsVerbatimArguments = true;
+      opts.stdio = [null, null, null, 'ipc'];
+    }
+    let child = spawn(command, args, opts);
+    let result = {
+      output: [],
+      errors: [],
+      code: null
+    };
+
+    if (options.onChildSpawned) {
+      let onChildSpawnedPromise = new Promise((childSpawnedResolve, childSpawnedReject) => {
+        try {
+          options.onChildSpawned(child).then(childSpawnedResolve, childSpawnedReject);
+        } catch (err) {
+          childSpawnedReject(err);
+        }
+      });
+      onChildSpawnedPromise
+        .then(() => {
+          if (options.killAfterChildSpawnedPromiseResolution) {
+            killCliProcess(child);
+          }
+        }, err => {
+          result.testingError = err;
+          if (options.killAfterChildSpawnedPromiseResolution) {
+            killCliProcess(child);
+          }
+        });
+    }
+
+    child.stdout.on('data', data => {
+      let string = data.toString();
+
+      options.onOutput(string, child);
+
+      result.output.push(string);
+    });
+
+    child.stderr.on('data', data => {
+      let string = data.toString();
+
+      options.onError(string, child);
+
+      result.errors.push(string);
+    });
+
+    child.on('close', (code, signal) => {
+      result.code = code;
+      result.signal = signal;
+
+      if (code === 0) {
+        resolve(result);
+      } else {
+        reject(result);
+      }
+    });
+  });
+};

test-packages/test-libs/run-ember.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const path = require('path');
+const findup = require('findup-sync');
+const runCommand = require('./run-command');
+
+module.exports = function(command, options) {
+  let emberCLIPath = findup('node_modules/ember-cli');
+
+  let args = [path.join(emberCLIPath, 'bin', 'ember'), command].concat(options);
+
+  return runCommand.apply(undefined, args);
+};

test-packages/test-libs/run-server.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const debug    = require('./debug');
+const runEmber = require('./run-ember');
+const defaults = require('lodash/defaults');
+
+module.exports = function runServer(options) {
+  return new Promise((resolve, reject) => {
+    options = options || { };
+
+    defaults(options, {
+      port: '49741',
+      command: 'server',
+      detectServerStart
+    });
+
+    let args = [
+      '--port', options.port
+    ];
+
+    if (options.additionalArguments) {
+      args = args.concat(options.additionalArguments);
+    }
+
+    let longRunningServerPromise;
+
+    let commandOptions = {
+      verbose: true,
+
+      onOutput(output, child) {
+        if (options.detectServerStart(output)) {
+          resolve({
+            server: child,
+            longRunningServerPromise
+          });
+        }
+      }
+    };
+
+    args.push(commandOptions);
+
+    debug('starting server; command=%s; port=%s', options.command, options.port);
+
+    longRunningServerPromise = runEmber(options.command, args)
+      .then(() => {
+        throw new Error('The server should not have exited successfully.');
+      })
+      .catch(reject);
+  });
+};
+
+function detectServerStart(output) {
+  let indicators = [
+    'Ember FastBoot running at',
+    'Build successful'
+  ];
+
+  for (let indicator of indicators) {
+    if (output.indexOf(indicator) > -1) {
+      return true;
+    }
+  }
+}