Plato - index.js

/*!
 *
 * Copyright (c) 2013 Sebastian Golasch
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 */

'use strict';

// ext. libs
var Q = require('q');
var cp = require('child_process');
var portscanner = require('portscanner');

// int. libs
var iedriver = require('./lib/iedriver');

/**
 * This module is a browser plugin for [DalekJS](//github.com/dalekjs/dalek).
 * It provides all a WebDriverServer & browser launcher for Internet Explorer.
 *
 * The browser plugin can be installed with the following command:
 *
 * ```bash
 * $ npm install dalek-browser-ie --save-dev
 * ```
 *
 * You can use the browser plugin by adding a config option to the your Dalekfile
 *
 * ```javascript
 * "browsers": ["IE"]
 * ```
 *
 * Or you can tell Dalek that it should test in this browser via the command line:
 *
 * ```bash
 * $ dalek mytest.js -b IE
 * ```
 *
 * The Webdriver Server tries to open Port 5555 by default,
 * if this port is blocked, it tries to use a port between 5555 & 5564
 * You can specifiy a different port from within your [Dalekfile](/pages/config.html) like so:
 *
 * ```javascript
 * "browsers": {
 *   "ie": {
 *     "port": 6555 
 *   }
 * }
 * ```
 *
 * It is also possible to specify a range of ports:
 *
 * ```javascript
 * "browsers": {
 *   "ie": {
 *     "portRange": [6100, 6120] 
 *   }
 * }
 * ```
 * 
 * @module DalekJS
 * @class InternetExplorer
 * @namespace Browser
 * @part InternetExplorer
 * @api
 */

var InternetExplorer = {

/**
   * Verbose version of the browser name
   *
   * @property longName
   * @type string
   * @default Internet Explorer
   * @api
   */

longName: 'Internet Explorer',

/**
   * Default port of the IEDriverServer
   * The port may change, cause the port conflict resultion
   * tool might pick another one, if the default one is blocked
   *
   * @property port
   * @type integer
   * @default 5555
   */

port: 5555,

/**
   * Default maximum port of the IEDriverServer
   * The port is the highest port in the range that can be allocated
   * by the IEDriverServer
   *
   * @property maxPort
   * @type integer
   * @default 5654
   */

maxPort: 5654,

/**
   * Default host of the IEDriverServer
   * The host may be overridden with
   * a user configured value
   *
   * @property host
   * @type string
   * @default localhost
   */

host: 'localhost',

/**
   * Default desired capabilities that should be
   * transferred when the browser session gets requested
   *
   * @property desiredCapabilities
   * @type object
   */

desiredCapabilities: {
    browserName: 'InternetExplorer',
    initialBrowserUrl: ''
  },

/**
   * Driver defaults, what should the driver be able to access.
   *
   * @property driverDefaults
   * @type object
   */

driverDefaults: {
    viewport: true,
    status: true,
    sessionInfo: true
  },

/**
   * Path to the IEDriverServer.exe file
   *
   * @property path
   * @type string
   * @default /
   */

path: '/',

/**
   * Child process instance of the IEDriverServer
   *
   * @property spawned
   * @type null|Object
   */

spawned: null,

/**
   * IE processes that are running on startup,
   * and therefor shouldn`t be closed
   *
   * @property openProcesses
   * @type array
   * @default []   
   */

openProcesses: [],

/**
   * Resolves the driver port
   *
   * @method getPort
   * @return {integer} port WebDriver server port
   */

getPort: function () {
    return this.port;
  },

/**
   * Returns the driver host
   *
   * @method getHost
   * @return {string} host WebDriver server hostname
   */

getHost: function () {
    return this.host;
  },

/**
   * Resolves the maximum range for the driver port
   *
   * @method getMaxPort
   * @return {integer} port Max WebDriver server port range
   */

getMaxPort: function () {
    return this.maxPort;
  },

/**
   * Launches the driver
   * (the driver takes care of launching the browser)
   *
   * @method launch
   * @return {object} promise Browser promise
   */

launch: function (configuration, events, config) {
    var deferred = Q.defer();

// store injected configuration/log event handlers
    this.reporterEvents = events;
    this.configuration = configuration;
    this.config = config;

// check for a user set port
    var browsers = this.config.get('browsers');
    if (browsers && Array.isArray(browsers)) {
      browsers.forEach(this._checkUserDefinedPorts.bind(this));
    }

// check if the current port is in use, if so, scan for free ports
    portscanner.findAPortNotInUse(this.getPort(), this.getMaxPort(), this.getHost(), this._checkPorts.bind(this, deferred));
    return deferred.promise;
  },

/**
   * Kills the driver & browser processes
   *
   * @method kill
   * @chainable
   */

kill: function () {
    // get a list of all running processes
    this._list(function(svc){
      // filter out the browser process
      svc.forEach(function (item, idx) {
        Object.keys(item).forEach(function (key) {
          if(svc[idx][key] === 'iexplore.exe') {
            // kill the browser process
            this._kill(svc[idx].PID, true);
          }
        }.bind(this));
      }.bind(this));
    }.bind(this),true);

// kill the driver process
    this.spawned.kill('SIGTERM');
    return this;
  },

_checkPorts: function (deferred, err, port) {
    // check if the port was blocked & if we need to switch to another port
    if (this.port !== port) {
      this.reporterEvents.emit('report:log:system', 'dalek-browser-ie: Switching to port: ' + port);
      this.port = port;
    }

// invoke the ie driver afterwards
    this._startIEdriver(deferred);
    return this;
  },

_startIEdriver: function (deferred) {
    var stream = '';
    this.spawned = cp.spawn(iedriver.path, ['--port=' + this.getPort()]);

this.spawned.stdout.on('data', function (data) {
      var dataStr = data + '';
      stream += dataStr;
      if (stream.search('Listening on port') !== -1) {
        deferred.resolve();
      }
    });
    return this;
  },

/**
   * Process user defined ports
   *
   * @method _checkUserDefinedPorts
   * @param {object} browser Browser configuration
   * @chainable
   * @private
   */

_checkUserDefinedPorts: function (browser) {
    // check for a single defined port
    if (browser.ie && browser.ie.port) {
      this.port = parseInt(browser.ie.port, 10);
      this.maxPort = this.port + 90;
      this.reporterEvents.emit('report:log:system', 'dalek-browser-ie: Switching to user defined port: ' + this.port);
    }

// check for a port range
    if (browser.ie && browser.ie.portRange && browser.ie.portRange.length === 2) {
      this.port = parseInt(browser.ie.portRange[0], 10);
      this.maxPort = parseInt(browser.ie.portRange[1], 10);
      this.reporterEvents.emit('report:log:system', 'dalek-browser-ie: Switching to user defined port(s): ' + this.port + ' -> ' + this.maxPort);
    }

return this;
  },

/**
   * Lists all running processes (win only)
   *
   * @method _list
   * @param {Function} callback Receives the process object as the only callback argument
   * @param {Boolean} [verbose=false] Verbose output
   * @chainable
   * @private
   */

_list: function(callback, verbose) {
    verbose = typeof verbose === 'boolean' ? verbose : false;
    cp.exec('tasklist /FO CSV' + (verbose === true ? ' /V' : ''), function (err, stdout) {
      var pi = stdout.split('\r\n');
      var p = [];

pi.forEach(function (line) {
        if (line.trim().length !== 0) {
          p.push(line);
        }
      });

var proc = [];
      var head = null;
      while (p.length > 1) {
        var rec = p.shift();
        rec = rec.replace(/\"\,/gi,'";').replace(/\"|\'/gi,'').split(';');
        if (head === null){
          head = rec;
          for (var i=0;i<head.length;i++){
            head[i] = head[i].replace(/ /gi,'');
          }

if (head.indexOf('PID')<0){
            head[1] = 'PID';
          }
        } else {
          var tmp = {};
          for (var j=0;j<rec.length;j++){
            tmp[head[j]] = rec[j].replace(/\"|\'/gi,'');
          }
          proc.push(tmp);
        }
      }
      callback(proc);
    });

return this;
  },

/**
   * Kill a specific process (win only)
   *
   * @method _kill
   * @param {Number} PID Process ID
   * @param {Boolean} [force=false] Force close the process.
   * @param {Function} [callback] Callback after process has been killed
   * @chainable
   * @private
   */

_kill: function(pid, force, callback) {
    if (!pid || isNaN(parseInt(pid))){
      throw new Error('PID is required for the kill operation.');
    }
    callback = callback || function(){};
    if (typeof force === 'function'){
      callback = force;
      force = false;
    }
    cp.exec('taskkill /PID ' + pid + (force === true ? ' /f' : ''),callback);
    return this;
  }

};

// expose the module
module.exports = InternetExplorer;

index.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC