Merge 25db7f6 into bfc6219

lib/gemini.js

@@ -3,17 +3,15 @@
 const debug = require('debug');
 const chalk = require('chalk');
 const _ = require('lodash');
-const passthroughEvent = require('qemitter/utils').passthroughEvent;
-const QEmitter = require('qemitter');
+const PassthroughEmitter = require('./passthrough-emitter');
 const qDebugMode = require('q-debug-mode');
 const q = require('q');
 
 const Config = require('./config');
 const GeminiError = require('./errors/gemini-error');
-const GeminiFacade = require('./gemini-facade');
 const readTests = require('./test-reader');
 const Runner = require('./runner');
-const RunnerEvents = require('./constants/runner-events');
+const Events = require('./constants/events');
 const RunnerStats = require('./stats');
 const StateProcessor = require('./state-processor');
 const SuiteCollection = require('./suite-collection');
@@ -27,14 +25,12 @@ const parseBrowsers = (browsers) => {
     return browsers && browsers.replace(/\s/g, '').split(',');
 };
 
-// Gemini needs to inherit from QEmitter rather then
-// EventEmmiter because it needs to allow `startRunner`
-// event handler delay the execution of tests
-module.exports = class Gemini extends QEmitter {
+module.exports = class Gemini extends PassthroughEmitter {
     constructor(config, allowOverrides) {
         super();
 
         this.config = new Config(config, allowOverrides);
+        this.events = Events;
         this.SuiteCollection = SuiteCollection;
 
         setupLog(this.config.system.debug);
@@ -58,8 +54,8 @@ module.exports = class Gemini extends QEmitter {
         const envSkipBrowsers = parseBrowsers(process.env.GEMINI_SKIP_BROWSERS);
         const browsers = options.browsers || envBrowsers;
 
-        this._passThroughRunnerEvents(runner);
-        this._loadPlugins(runner);
+        this._passThroughEvents(runner);
+        this._loadPlugins();
 
         if (browsers) {
             this.checkUnknownBrowsers(browsers);
@@ -89,15 +85,12 @@ module.exports = class Gemini extends QEmitter {
             });
     }
 
-    _passThroughRunnerEvents(runner) {
-        passthroughEvent(runner, this, [
-            RunnerEvents.START_RUNNER,
-            RunnerEvents.END_RUNNER
-        ]);
+    _passThroughEvents(runner) {
+        this.passthroughEvent(runner, _.values(Events));
     }
 
-    _loadPlugins(runner) {
-        require('./plugins').load(new GeminiFacade(runner));
+    _loadPlugins() {
+        require('./plugins').load(this);
     }
 
     readTests(paths, options) {

lib/passthrough-emitter.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const _ = require('lodash'),
+    QEmitter = require('qemitter');
+
+module.exports = class PassthroughEmitter extends QEmitter {
+
+    // Allow to pass only one argument with event
+    emit(type, data) {
+        return super.emit(type, data);
+    }
+
+    emitAndWait(type, data) {
+        return super.emitAndWait(type, data, {shouldWait: true});
+    }
+
+    /**
+     * Emit event emitted by emitter
+     * @param {EventEmitter} emitter
+     * @param {String|String[]} event or array of events to passthrough
+     */
+    passthroughEvent(emitter, event) {
+        if (_.isArray(event)) {
+            event.forEach(this.passthroughEvent.bind(this, emitter));
+            return;
+        }
+
+        emitter.on(event, function(data, opts) {
+            if (opts && opts.shouldWait) {
+                return this.emitAndWait(event, data);
+            } else {
+                this.emit(event, data);
+            }
+        }.bind(this));
+    }
+};
+
+

lib/reporters/flat-factory/flat.js

@@ -6,7 +6,7 @@ const chalk = require('chalk');
 const logger = require('../../utils').logger;
 const TestCounter = require('../utils/test-counter');
 
-const RunnerEvents = require('../../constants/runner-events');
+const Events = require('../../constants/events');
 
 const ICON_SUCCESS = chalk.green('✓');
 const ICON_NOT_UPDATED = chalk.gray('✓');
@@ -20,14 +20,14 @@ module.exports = class Flat {
     }
 
     attachRunner(runner) {
-        runner.on(RunnerEvents.TEST_RESULT, this._onTestResult.bind(this));
-        runner.on(RunnerEvents.UPDATE_RESULT, this._onUpdateResult.bind(this));
-        runner.on(RunnerEvents.RETRY, this._onRetry.bind(this));
-        runner.on(RunnerEvents.ERROR, this._onError.bind(this));
-        runner.on(RunnerEvents.WARNING, this._onWarning.bind(this));
-        runner.on(RunnerEvents.END, this._onEnd.bind(this));
-        runner.on(RunnerEvents.INFO, this._onInfo.bind(this));
-        runner.on(RunnerEvents.SKIP_STATE, this._onSkipState.bind(this));
+        runner.on(Events.TEST_RESULT, this._onTestResult.bind(this));
+        runner.on(Events.UPDATE_RESULT, this._onUpdateResult.bind(this));
+        runner.on(Events.RETRY, this._onRetry.bind(this));
+        runner.on(Events.ERROR, this._onError.bind(this));
+        runner.on(Events.WARNING, this._onWarning.bind(this));
+        runner.on(Events.END, this._onEnd.bind(this));
+        runner.on(Events.INFO, this._onInfo.bind(this));
+        runner.on(Events.SKIP_STATE, this._onSkipState.bind(this));
     }
 
     _compile(tmpl, data) {

lib/reporters/html/index.js

@@ -11,7 +11,7 @@ var path = require('path'),
     chalk = require('chalk'),
     logger = require('../../utils').logger,
 
-    RunnerEvents = require('../../constants/runner-events');
+    Events = require('../../constants/events');
 
 /**
  * @param {String} srcPath
@@ -44,22 +44,22 @@ function prepareViewData(runner) {
     var result = q.defer(),
         model = new ViewModel();
 
-    runner.on(RunnerEvents.SKIP_STATE, model.addSkipped.bind(model));
+    runner.on(Events.SKIP_STATE, model.addSkipped.bind(model));
 
-    runner.on(RunnerEvents.TEST_RESULT, function(r) {
+    runner.on(Events.TEST_RESULT, function(r) {
         if (r.equal) {
             model.addSuccess(r);
         } else {
             model.addFail(r);
         }
     });
 
-    runner.on(RunnerEvents.RETRY, model.addRetry.bind(model));
+    runner.on(Events.RETRY, model.addRetry.bind(model));
 
-    runner.on(RunnerEvents.ERROR, model.addError.bind(model));
-    runner.on(RunnerEvents.WARNING, model.addWarning.bind(model));
+    runner.on(Events.ERROR, model.addError.bind(model));
+    runner.on(Events.WARNING, model.addWarning.bind(model));
 
-    runner.on(RunnerEvents.END, function() {
+    runner.on(Events.END, function() {
         result.resolve(model.getResult());
     });
 
@@ -80,33 +80,33 @@ function prepareImages(runner) {
     var imagesReady = q.defer(),
         queue = q(true);
 
-    runner.on(RunnerEvents.WARNING, function(testResult) {
+    runner.on(Events.WARNING, function(testResult) {
         queue = queue.then(function() {
             return copyImage(testResult.currentPath, lib.currentAbsolutePath(testResult));
         });
     });
 
-    runner.on(RunnerEvents.ERROR, function(testResult) {
+    runner.on(Events.ERROR, function(testResult) {
         queue = queue.then(function() {
             return handleErrorEvent_(testResult);
         });
     });
 
-    runner.on(RunnerEvents.RETRY, function(testResult) {
+    runner.on(Events.RETRY, function(testResult) {
         queue = queue.then(function() {
             return testResult.hasOwnProperty('equal')
                 ? handleTestResultEvent_(testResult)
                 : handleErrorEvent_(testResult);
         });
     });
 
-    runner.on(RunnerEvents.TEST_RESULT, function(testResult) {
+    runner.on(Events.TEST_RESULT, function(testResult) {
         queue = queue.then(function() {
             return handleTestResultEvent_(testResult);
         });
     });
 
-    runner.on(RunnerEvents.END, function() {
+    runner.on(Events.END, function() {
         logPathToHtmlReport();
 
         queue.then(imagesReady.resolve, imagesReady.reject);

lib/runner/browser-runner/index.js

@@ -6,7 +6,7 @@ const promiseUtils = require('q-promise-utils');
 const BrowserAgent = require('./browser-agent');
 const Runner = require('../runner');
 const SuiteRunner = require('../suite-runner');
-const RunnerEvents = require('../../constants/runner-events');
+const Events = require('../../constants/events');
 
 const log = require('debug')('gemini:runner');
 
@@ -26,11 +26,11 @@ module.exports = class BrowserRunner extends Runner {
 
     run(suiteCollection, stateProcessor) {
         log('start browser %s', this._browserId);
-        this.emit(RunnerEvents.START_BROWSER, {browserId: this._browserId});
+        this.emit(Events.START_BROWSER, {browserId: this._browserId});
         return this._runSuites(suiteCollection, stateProcessor)
             .finally(() => {
                 log('stop browser %s', this._browserId);
-                this.emit(RunnerEvents.STOP_BROWSER, {browserId: this._browserId});
+                this.emit(Events.STOP_BROWSER, {browserId: this._browserId});
             });
     }
 
@@ -58,17 +58,17 @@ module.exports = class BrowserRunner extends Runner {
         const runner = SuiteRunner.create(suite, browserAgent, this._config);
 
         this.passthroughEvent(runner, [
-            RunnerEvents.BEGIN_SUITE,
-            RunnerEvents.END_SUITE,
-            RunnerEvents.SKIP_STATE,
-            RunnerEvents.BEGIN_STATE,
-            RunnerEvents.END_STATE,
-            RunnerEvents.TEST_RESULT,
-            RunnerEvents.CAPTURE,
-            RunnerEvents.UPDATE_RESULT,
-            RunnerEvents.WARNING,
-            RunnerEvents.ERROR,
-            RunnerEvents.RETRY
+            Events.BEGIN_SUITE,
+            Events.END_SUITE,
+            Events.SKIP_STATE,
+            Events.BEGIN_STATE,
+            Events.END_STATE,
+            Events.TEST_RESULT,
+            Events.CAPTURE,
+            Events.UPDATE_RESULT,
+            Events.WARNING,
+            Events.ERROR,
+            Events.RETRY
         ]);
 
         this._suiteRunners.push(runner);

lib/runner/index.js

@@ -5,7 +5,7 @@ const q = require('q');
 const Runner = require('./runner');
 const TestSessionRunner = require('./test-session-runner');
 const Coverage = require('../coverage');
-const RunnerEvents = require('../constants/runner-events');
+const Events = require('../constants/events');
 
 module.exports = class TestsRunner extends Runner {
     static create(config, stateProcessor) {
@@ -32,8 +32,8 @@ module.exports = class TestsRunner extends Runner {
         const suites = suiteCollection.allSuites();
 
         return q.fcall(() => {
-            this.emit(RunnerEvents.START_RUNNER, this);
-            this.emit(RunnerEvents.BEGIN, {
+            this.emit(Events.START_RUNNER, this);
+            this.emit(Events.BEGIN, {
                 config: this.config,
                 totalStates: _.reduce(suites, (result, suite) => {
                     return result + suite.states.length;
@@ -45,33 +45,33 @@ module.exports = class TestsRunner extends Runner {
         .then(() => this._runTestSession(suiteCollection))
         .then(() => this.coverage && this.coverage.processStats())
         .finally(() => {
-            this.emit(RunnerEvents.END);
-            this.emit(RunnerEvents.END_RUNNER, this);
+            this.emit(Events.END);
+            this.emit(Events.END_RUNNER, this);
         });
     }
 
     _runTestSession(suiteCollection) {
         const sessionRunner = TestSessionRunner.create(this.config, this._testBrowsers);
 
         this.passthroughEvent(sessionRunner, [
-            RunnerEvents.BEGIN_SESSION,
-            RunnerEvents.END_SESSION,
-            RunnerEvents.START_BROWSER,
-            RunnerEvents.STOP_BROWSER,
-            RunnerEvents.INFO,
-            RunnerEvents.BEGIN_SUITE,
-            RunnerEvents.END_SUITE,
-            RunnerEvents.SKIP_STATE,
-            RunnerEvents.BEGIN_STATE,
-            RunnerEvents.END_STATE,
-            RunnerEvents.ERROR,
-            RunnerEvents.WARNING,
-            RunnerEvents.RETRY
+            Events.BEGIN_SESSION,
+            Events.END_SESSION,
+            Events.START_BROWSER,
+            Events.STOP_BROWSER,
+            Events.INFO,
+            Events.BEGIN_SUITE,
+            Events.END_SUITE,
+            Events.SKIP_STATE,
+            Events.BEGIN_STATE,
+            Events.END_STATE,
+            Events.ERROR,
+            Events.WARNING,
+            Events.RETRY
         ]);
 
-        sessionRunner.on(RunnerEvents.TEST_RESULT, (result) => this._handleTestResult(result));
-        sessionRunner.on(RunnerEvents.CAPTURE, (result) => this._handleCapture(result));
-        sessionRunner.on(RunnerEvents.UPDATE_RESULT, (result) => this._handleUpdateResult(result));
+        sessionRunner.on(Events.TEST_RESULT, (result) => this._handleTestResult(result));
+        sessionRunner.on(Events.CAPTURE, (result) => this._handleCapture(result));
+        sessionRunner.on(Events.UPDATE_RESULT, (result) => this._handleUpdateResult(result));
 
         return sessionRunner.run(suiteCollection, this._stateProcessor);
     }
@@ -83,18 +83,18 @@ module.exports = class TestsRunner extends Runner {
     _handleTestResult(result) {
         this._saveCoverage(result);
 
-        this.emit(RunnerEvents.END_TEST, result);
-        this.emit(RunnerEvents.TEST_RESULT, result);
+        this.emit(Events.END_TEST, result);
+        this.emit(Events.TEST_RESULT, result);
     }
 
     _handleCapture(result) {
         this._saveCoverage(result);
-        this.emit(RunnerEvents.CAPTURE, result);
+        this.emit(Events.CAPTURE, result);
     }
 
     _handleUpdateResult(result) {
         this._saveCoverage(result);
-        this.emit(RunnerEvents.UPDATE_RESULT, result);
+        this.emit(Events.UPDATE_RESULT, result);
     }
 
     _saveCoverage(data) {