Refactor the code which starts firefox during integration tests so that it can be reused for other things

Author: Joris-van-der-Wel

lib/explicitPromise.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const explicitPromise = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return [promise, resolve, reject];
+};
+
+module.exports = explicitPromise;

test/utilities/Process.js lib/node/Process.jstest/utilities/Process.js renamed to lib/node/Process.js

@@ -6,31 +6,33 @@ const {spawn} = require('child_process');
 const split = require('split');
 const {assert} = require('chai');
 
-const log = require('../../lib/logger')({hostname: 'test', MODULE: 'Process'});
+const log = require('../logger')({MODULE: 'node/Process'});
+const explicitPromise = require('../explicitPromise');
 
+/**
+ * Launch a system process (requires node.js) and manage its lifecycle and standard streams.
+ */
 class Process extends EventEmitter {
-    constructor({executablePath, args, env, cwd, enableExtraFd, outputFilter = s => s}) {
+    constructor({executablePath, args, env, cwd, enableExtraFd, outputFilter = s => s, killTimeout = 10000}) {
         super();
         this.executablePath = executablePath;
         this.args = args || [];
         this.env = env || {};
         this.cwd = cwd || undefined; // undefined = inherit
         this.enableExtraFd = Boolean(enableExtraFd || false);
         this.outputFilter = outputFilter;
+        this.killTimeout = killTimeout;
 
         this.runningChild = null;
-        this.childrenLifeTime = Promise.resolve();
         this.lastProcessStart = NaN;
         this.lastProcessExit = NaN;
         this.processExitCount = 0;
-
-        this._lastStartSymbol = null;
+        this._childLifeTime = Promise.resolve();
     }
 
     _waitableEmit(event, ...args) {
         const waits = [];
         this.emit(event, ...args, p => waits.push(typeof p === 'function' ? p() : p));
-
         return Promise.all(waits);
     }
 
@@ -51,33 +53,12 @@ class Process extends EventEmitter {
     async start() {
         assert.isNotOk(this.runningChild, 'start(): The child process has already been started');
 
-        const lastStartSymbol = Symbol();
-        this._lastStartSymbol = lastStartSymbol;
-
-        let lifeTimeResolve;
-        let lifeTimeReject;
-
-        const childLifeTime = new Promise((resolve, reject) => {
-            lifeTimeResolve = resolve;
-            lifeTimeReject = reject;
-        })
-        .finally(() => {
-            if (this._lastStartSymbol === lastStartSymbol) {
-                this.runningChild = null;
-            }
-        });
-
-        this.childrenLifeTime = this.childrenLifeTime
-        .finally(async () => {
-            await childLifeTime;
-
-            if (this._lastStartSymbol === lastStartSymbol) {
-                await this._waitableEmit('stopped');
-                log.info('Process stopped');
-                this.emit('afterStopped');
-            }
-
-            return null;
+        const [lifeTimePromise, lifeTimeResolve] = explicitPromise();
+        this._childLifeTime = lifeTimePromise.then(async (reason) => {
+            this.runningChild = null;
+            await this._waitableEmit('stopped', reason);
+            log.info('Process stopped');
+            this.emit('afterStopped', reason);
         });
 
         // set this value right away to make sure that we never create duplicate processes
@@ -125,14 +106,14 @@ class Process extends EventEmitter {
                 log.info({code, executablePath, signal}, 'Process exit');
                 this.lastProcessExit = Date.now();
                 ++this.processExitCount;
-                lifeTimeResolve({code, signal});
+                lifeTimeResolve(Object.freeze({error: null, code, signal}));
             });
 
             childProcess.on('error', err => {
                 // The process could not be spawned, or The process could not be killed, or Sending a message to the child process
                 // failed.
                 log.error({childPid, err, executablePath}, 'Error spawning process');
-                lifeTimeReject(err);
+                lifeTimeResolve(Object.freeze({error: err}));
             });
 
             childProcess.stdout.pipe(split()).on('data', line => {
@@ -166,24 +147,21 @@ class Process extends EventEmitter {
                     this.emit('FD3', line);
                 });
             }
+
+            await this._waitableEmit('afterStart');
         }
         catch (err) {
-            lifeTimeReject(err);
+            lifeTimeResolve(Object.freeze({error: err}));
             throw err;
         }
-
-        // try to throw if the child immediately fails to start:
-        await Promise.race([Promise.delay(10), childLifeTime]);
-        await this._waitableEmit('afterStart');
     }
 
     async stop() {
         if (!this.runningChild ||
             this.runningChild.stopping ||
             !this.runningChild.childProcess) {
             // already stopping or there was an error creating the childProcess
-            await this.childrenLifeTime.catch(() => {});
-
+            await this.waitForChildStop();
             return;
         }
 
@@ -199,11 +177,15 @@ class Process extends EventEmitter {
             // SIGKILL = forceful termination
             log.info({signal: 'SIGKILL'}, 'Stopping process');
             childProcess.kill('SIGKILL');
-        }, 10000);
+        }, this.killTimeout);
 
-        await this.childrenLifeTime.catch(() => {});
+        await this.waitForChildStop();
         clearTimeout(killTimer);
     }
+
+    async waitForChildStop() {
+        await this._childLifeTime;
+    }
 }
 
 module.exports = Process;

lib/node/firefoxProcess.js

@@ -0,0 +1,58 @@
+'use strict';
+const Promise = require('bluebird');
+
+const Process = require('./Process');
+const log = require('../logger')({MODULE: 'node/firefoxProcess'});
+
+const outputFilter = line => {
+    // hide a lot of useless noise during test runs
+
+    // Linux:
+    // (firefox:6881): GLib-GObject-CRITICAL **: g_object_ref: assertion 'object->ref_count > 0' failed
+    // (firefox:6881): GConf-WARNING **: Client failed to connect to the D-BUS daemon:
+    // //bin/dbus-launch terminated abnormally without any error message
+
+    // OS X:
+    // 2017-01-01 12:34:56.789 plugin-container[17512:1629725] *** CFMessagePort: bootstrap_register(): failed 1100 (0x44c)
+    //   'Permission denied', port = 0xb03f, name = 'com.apple.tsm.portname'
+    // See /usr/include/servers/bootstrap_defs.h for the error codes.
+    // Unable to read VR Path Registry from /Users/FOO/Library/Application Support/OpenVR/.openvr/openvrpaths.vrpath
+    if (
+        /^\(.*?firefox.*?\): (?:GLib-GObject-CRITICAL|GConf-WARNING) /.test(line) ||
+        line === '//bin/dbus-launch terminated abnormally without any error message' ||
+        /plugin-container.*?\*\*\* CFMessagePort: bootstrap_register\(\): failed 1100/.test(line) ||
+        line === 'See /usr/include/servers/bootstrap_defs.h for the error codes.' ||
+        /^Unable to read VR Path Registry from /.test(line)
+    ) {
+        return null; // skip the log line
+    }
+
+    return line;
+};
+
+const startFirefox = ({firefoxPath, profilePath, headless = false}) => Promise.try(async () => {
+    log.debug({firefoxPath, profilePath}, 'Starting firefox...');
+    const args = [
+        '--no-remote',
+        '--profile',
+        profilePath,
+    ];
+
+    if (headless) {
+        args.push('--headless');
+    }
+
+    const firefoxProcess = new Process({
+        executablePath: firefoxPath,
+        args,
+        outputFilter,
+    });
+    await firefoxProcess.start();
+    return firefoxProcess;
+})
+.disposer(async firefoxProcess => {
+    log.debug({firefoxPath, profilePath}, 'Stopping firefox...');
+    await firefoxProcess.stop();
+});
+
+module.exports = {startFirefox};