diff --git a/lib/cli.js b/lib/cli.js
index 54a88d2bc..83f7c11f4 100644
--- a/lib/cli.js
+++ b/lib/cli.js
@@ -1,6 +1,6 @@
 /**
  * The command line interface for interacting with the Protractor runner.
- * It takes care of parsing the config file and command line options.
+ * It takes care of parsing command line options.
  *
  * Values from command line options override values from the config.
  */
@@ -67,13 +67,16 @@ if (argv.version) {
   process.exit(0);
 }
 
-// WebDriver capabilities properties require dot notation.
+// WebDriver capabilities properties require dot notation, but optimist parses
+// that into an object. Re-flatten it.
 var flattenObject = function(obj) {
   var prefix = arguments[1] || '';
   var out = arguments[2] || {};
     for (var prop in obj) {
       if (obj.hasOwnProperty(prop)) {
-        typeof obj[prop] === 'object' ? flattenObject(obj[prop], prefix + prop + '.', out) : out[prefix + prop] = obj[prop];
+        typeof obj[prop] === 'object' ?
+            flattenObject(obj[prop], prefix + prop + '.', out) :
+            out[prefix + prop] = obj[prop];
       }
     }
   return out;
@@ -83,5 +86,27 @@ if (argv.capabilities) {
   argv.capabilities = flattenObject(argv.capabilities);
 }
 
+/**
+ * Helper to resolve comma separated lists of file pattern strings relative to
+ * the cwd.
+ *
+ * @private
+ * @param {Array} list
+ */
+var processFilePatterns_ = function(list) {
+  var patterns = list.split(',');
+  patterns.forEach(function(spec, index, arr) {
+    arr[index] = path.resolve(process.cwd(), spec);
+  });
+  return patterns;
+};
+
+if (argv.specs) {
+  argv.specs = processFilePatterns_(argv.specs);
+}
+if (argv.excludes) {
+  argv.excludes = processFilePatterns_(argv.excludes);
+}
+
 // Run the launcher
 require('./launcher').init(argv);
diff --git a/lib/configParser.js b/lib/configParser.js
index a638d675e..fddc7d00b 100644
--- a/lib/configParser.js
+++ b/lib/configParser.js
@@ -1,38 +1,38 @@
 var path = require('path'),
     glob = require('glob'),
-    config_ = {
-      configDir: './',
-      jasmineNodeOpts: {}
-    },
-    //this allows for ease of maintaining public apis of the config while still
-    //  allowing for easy variable renames or future config api changes while
-    //  supported backwards compatibility
-    configMap_ = {
+    util = require('util'),
+    protractor = require('./protractor.js');
+
 
-      //structure is internal name -> supported config apis
-      'specs': ['specs'],
-      'exclude': ['exclude'],
-      'capabilities': ['capabilities'],
-      'seleniumHost': ['seleniumAddress'],
-      'rootElement': ['rootElement'],
-      'baseUrl': ['baseUrl'],
-      'timeout': ['allScriptsTimeout'],
-      'browserParams': ['params'],
-      'framework': ['framework'],
-      'jasmineOpts': ['jasmineNodeOpts'],
-      'mochaOpts': ['mochaOpts'],
-      'seleniumLocal.jar': ['seleniumServerJar'],
-      'seleniumLocal.args': ['seleniumArgs'],
-      'seleniumLocal.port': ['seleniumPort'],
-      'sauceAccount.user': ['sauceUser'],
-      'sauceAccount.key': ['sauceKey'],
-      'chromeDriver': ['chromeDriver'],
-      'chromeOnly': ['chromeOnly'],
-      'configDir': ['configDir'],
-      'cucumberOpts.require': ['cucumberOpts.require'],
-      'cucumberOpts.format': ['cucumberOpts.format'],
-      'cucumberOpts.tags': ['cucumberOpts.tags']
-    };
+module.exports = ConfigParser = function() {
+  // Default configuration.
+  this.config_= {
+    specs: [],
+    capabilities: {
+      browserName: 'chrome'
+    },
+    multiCapabilities: [],
+    rootElement: 'body',
+    allScriptsTimeout: 11000,
+    params: {},
+    framework: 'jasmine',
+    jasmineNodeOpts: {
+      isVerbose: false,
+      showColors: true,
+      includeStackTrace: true,
+      stackFilter: protractor.filterStackTrace,
+      defaultTimeoutInterval: (30 * 1000)
+    },
+    seleniumArgs: [],
+    cucumberOpts: {},
+    mochaOpts: {
+      ui: 'bdd',
+      reporter: 'list'
+    },
+    chromeDriver: null,
+    configDir: './'
+  };
+};
 
 /**
  * Merge config objects together.
@@ -57,145 +57,76 @@ var merge_ = function(into, from) {
 /**
  * Resolve a list of file patterns into a list of individual file paths.
  *
- * @param {Array/String} patterns
- * @param {Boolean} opt_omitWarnings  whether to omit did not match warnings
+ * @param {Array.<string> | string} patterns
+ * @param {=boolean} opt_omitWarnings Whether to omit did not match warnings
+ * @param {=string} opt_relativeTo Path to resolve patterns against
  *
  * @return {Array} The resolved file paths.
  */
-var resolveFilePatterns = function(patterns, opt_omitWarnings) {
+ConfigParser.resolveFilePatterns =
+    function(patterns, opt_omitWarnings, opt_relativeTo) {
   var resolvedFiles = [];
+  var cwd = opt_relativeTo || process.cwd();
 
   patterns = (typeof patterns === 'string') ?
       [patterns] : patterns;
 
   if (patterns) {
     for (var i = 0; i < patterns.length; ++i) {
-      var matches = glob.sync(patterns[i], {cwd: config_.configDir});
+      var matches = glob.sync(patterns[i], {cwd: cwd});
       if (!matches.length && !opt_omitWarnings) {
         util.puts('Warning: pattern ' + patterns[i] + ' did not match any files.');
       }
       for (var j = 0; j < matches.length; ++j) {
-        resolvedFiles.push(path.resolve(config_.configDir, matches[j]));
+        resolvedFiles.push(path.resolve(cwd, matches[j]));
       }
     }
   }
   return resolvedFiles;
 };
 
-/**
- * Helper to resolve file pattern strings relative to the cwd
- *
- * @private
- * @param {Array} list
- */
-var processFilePatterns_ = function(list) {
-  var patterns = list.split(',');
-  patterns.forEach(function(spec, index, arr) {
-    arr[index] = path.resolve(process.cwd(), spec);
-  });
-  return patterns;
-};
 
 /**
  * Add the options in the parameter config to this runner instance.
  *
  * @private
  * @param {Object} additionalConfig
+ * @param {string} relativeTo the file path to resolve paths against
  */
-var addConfig_ = function(additionalConfig) {
+ConfigParser.prototype.addConfig_ = function(additionalConfig, relativeTo) {
   // All filepaths should be kept relative to the current config location.
   // This will not affect absolute paths.
   ['seleniumServerJar', 'chromeDriver', 'onPrepare'].forEach(function(name) {
-    if (additionalConfig[name] && additionalConfig.configDir &&
-      typeof additionalConfig[name] === 'string') {
+    if (additionalConfig[name] && typeof additionalConfig[name] === 'string') {
       additionalConfig[name] =
-          path.resolve(additionalConfig.configDir, additionalConfig[name]);
+          path.resolve(relativeTo, additionalConfig[name]);
     }
   });
 
-  // Make sure they're not trying to add in deprecated config vals
+  // Make sure they're not trying to add in deprecated config vals.
   if (additionalConfig.jasmineNodeOpts &&
         additionalConfig.jasmineNodeOpts.specFolders) {
     throw new Error('Using config.jasmineNodeOpts.specFolders is deprecated ' +
         'since Protractor 0.6.0. Please switch to config.specs.');
   }
-  merge_(config_,additionalConfig);
+  merge_(this.config_, additionalConfig);
 };
 
-
-/**
- * Merges in passed in configuration data with existing class defaults
- * @public
- * @param {Object} config - A set of properties collected that will be merged
- *    with AbstractTestRunner defaults
- */
-var loadConfig = function(configObj, configToLoad) {
-
-  if (!configToLoad || !configObj) {
-    return;
-  }
-
-  /* helper to set the correct value for string dot notation */
-  function setConfig_(obj, str, val) {
-    str = str.split('.');
-    while (str.length > 1) {
-      obj = obj[str.shift()];
-    }
-    obj[str.shift()] = val;
-  }
-
-  /* helper to retrieve the correct value for string dot notation */
-  function getConfig_(obj, str) {
-    var arr = str.split(".");
-    while(arr.length && (obj = obj[arr.shift()]));
-    return obj;
-  }
-
-  /* helper to determine whether a config value is empty based on type */
-  function isEmpty_(val) {
-    return ( val !== null &&
-        val !== '' &&
-        val !== undefined &&
-        !(val instanceof Array &&
-            !val.length) &&
-        !(val instanceof Object &&
-          !Object.keys(val).length)
-      );
-  }
-
-  //object definition driven merging
-  var key,configDef,configAlias,i;
-  for (key in configMap_) {
-
-    configDef = configMap_[key];
-    for (i=0; i<configDef.length; i++) {
-      configAlias = configDef[i];
-      var configVal = getConfig_(configToLoad,configAlias);
-      if (isEmpty_(configVal)) {
-        //override config default w/ passed in config
-        setConfig_(configObj,key,configVal);
-      }
-    }
-  }
-};
-
-
-
-
 /**
  * Public function specialized towards merging in a file's config
  *
  * @public
  * @param {String} filename
  */
-var addFileConfig = function(filename) {
+ConfigParser.prototype.addFileConfig = function(filename) {
   if (!filename) {
-      return;
+    return;
   }
   var filePath = path.resolve(process.cwd(), filename);
   var fileConfig = require(filePath).config;
   fileConfig.configDir = path.dirname(filePath);
-  addConfig_(fileConfig);
+  this.addConfig_(fileConfig, fileConfig.configDir);
+  return this;
 };
 
 
@@ -205,19 +136,9 @@ var addFileConfig = function(filename) {
  * @public
  * @param {Object} argv
  */
-var addArgvConfig = function(argv) {
-  if (!argv) {
-      return;
-  }
-  // Interpret/parse spec include/exclude patterns
-  if (argv.specs) {
-    argv.specs = processFilePatterns_(argv.specs);
-  }
-  if (argv.exclude) {
-    argv.exclude = processFilePatterns(argv.exclude);
-  }
-
-  addConfig_(argv);
+ConfigParser.prototype.addConfig = function(argv) {
+  this.addConfig_(argv, process.cwd());
+  return this;
 };
 
 
@@ -227,13 +148,6 @@ var addArgvConfig = function(argv) {
  * @public
  * @return {Object} config
  */
-var getConfig = function() {
-  return config_;
+ConfigParser.prototype.getConfig = function() {
+  return this.config_;
 };
-
-
-exports.addArgvConfig = addArgvConfig;
-exports.addFileConfig = addFileConfig;
-exports.getConfig = getConfig;
-exports.loadConfig = loadConfig;
-exports.resolveFilePatterns = resolveFilePatterns;
\ No newline at end of file
diff --git a/lib/driverProviders/chrome.dp.js b/lib/driverProviders/chrome.dp.js
index 66616cb49..eae94c423 100644
--- a/lib/driverProviders/chrome.dp.js
+++ b/lib/driverProviders/chrome.dp.js
@@ -1,64 +1,76 @@
 /*
  *  This is an implementation of the Chrome Driver Provider.
  *  It is responsible for setting up the account object, tearing
- *    it down, and setting up the driver correctly.
+ *  it down, and setting up the driver correctly.
  */
 
 var util = require('util'),
     webdriver = require('selenium-webdriver'),
     chrome = require('selenium-webdriver/chrome'),
-    q = require('q');
+    q = require('q'),
+    fs = require('fs'),
+    path = require('path');
 
-function ChromeDriverProvider(testRunner) {
-
-  this.testRunner_ = testRunner;
-  this.trConfig_ = this.testRunner_.getConfig();
+var ChromeDriverProvider = function(config) {
+  this.config_ = config;
   this.driver_ = null;
-}
+};
 
 /**
- * setupEnv is responsible for configuring and launching (if applicable)
- * the object's environment.
+ * Configure and launch (if applicable) the object's environment.
  * @public
- * @return promise
+ * @return {q.promise} A promise which will resolve when the environment is
+ *     ready to test.
  */
 ChromeDriverProvider.prototype.setupEnv = function() {
-  var deferred = q.defer();
   util.puts('Using ChromeDriver directly...');
-  deferred.resolve();
-  return deferred.promise;
+  return q.fcall(function() {});
 };
 
 /**
- * teardownEnv is responsible for destroying the environment and doing any
- * associated cleanup.
+ * Teardown and destroy the environment and do any associated cleanup.
+ * Shuts down the driver.
+ *
  * @public
- * @param {runnerResult} runner 
+ * @return {q.promise} A promise which will resolve when the environment
+ *     is down.
  */
-ChromeDriverProvider.prototype.teardownEnv = function(runner) {
-  var deferred = q.defer(),
-      passed = runner.results().failedCount === 0,
-      exitCode = passed ? 0 : 1;
-
-  deferred.resolve(exitCode);
+ChromeDriverProvider.prototype.teardownEnv = function() {
+  var deferred = q.defer();
+  this.driver_.quit().then(function() {
+    deferred.resolve();
+  });
   return deferred.promise;
 };
 
 /**
- * getDriver is responsible for retrieving the webdriver for the runner.
+ * Retrieve the webdriver for the runner.
  * @public
  * @return webdriver instance
  */
 ChromeDriverProvider.prototype.getDriver = function() {
   if (!this.driver_) {
-    var service = new chrome.ServiceBuilder(this.trConfig_.chromeDriver).build();
+    var chromeDriverFile = this.config_.chromeDriver ||
+        path.resolve(__dirname, '../../selenium/chromedriver');
+
+    // Check if file exists, if not try .exe or fail accordingly
+    if (!fs.existsSync(chromeDriverFile)) {
+      chromeDriverFile += '.exe';
+      // Throw error if the client specified conf chromedriver and its not found
+      if (!fs.existsSync(chromeDriverFile)) {
+        throw new Error('Could not find chromedriver at ' +
+          chromeDriverFile);
+      }
+    }
+
+    var service = new chrome.ServiceBuilder(chromeDriverFile).build();
     this.driver_ = chrome.createDriver(
-    new webdriver.Capabilities(this.trConfig_.capabilities), service);
+        new webdriver.Capabilities(this.config_.capabilities), service);
   }
   return this.driver_;
 };
 
-//new instance w/ each include
-module.exports = (function(testRunner) {
-  return new ChromeDriverProvider(testRunner);
-});
\ No newline at end of file
+// new instance w/ each include
+module.exports = (function(config) {
+  return new ChromeDriverProvider(config);
+});
diff --git a/lib/driverProviders/hosted.dp.js b/lib/driverProviders/hosted.dp.js
index 4fa038571..2af0c35cb 100644
--- a/lib/driverProviders/hosted.dp.js
+++ b/lib/driverProviders/hosted.dp.js
@@ -1,7 +1,7 @@
 /*
  *  This is an implementation of the Hosted Driver Provider.
  *  It is responsible for setting up the account object, tearing
- *    it down, and setting up the driver correctly.
+ *  it down, and setting up the driver correctly.
  */
 
 var util = require('util'),
@@ -9,56 +9,54 @@ var util = require('util'),
     q = require('q');
 
 
-function HostedDriverProvider(testRunner) {
-
-  this.testRunner_ = testRunner;
-  this.trConfig_ = this.testRunner_.getConfig();
+var HostedDriverProvider = function(config) {
+  this.config_ = config;
   this.driver_ = null;
-}
+};
 
 /**
- * setupEnv is responsible for configuring and launching (if applicable)
- * the object's environment.
+ * Configure and launch (if applicable) the object's environment.
  * @public
- * @return promise
+ * @return {q.promise} A promise which will resolve when the environment is
+ *     ready to test.
  */
 HostedDriverProvider.prototype.setupEnv = function() {
-  var deferred = q.defer();
-  util.puts('Using the selenium server at ' + this.trConfig_.seleniumHost);
-  deferred.resolve(this.trConfig_.seleniumHost);
-  return deferred.promise;
+  util.puts('Using the selenium server at ' + this.config_.seleniumAddress);
+  return q.fcall(function() {});
 };
 
 /**
- * teardownEnv is responsible for destroying the environment and doing any
- * associated cleanup.
+ * Teardown and destroy the environment and do any associated cleanup.
+ * Shuts down the driver.
+ *
  * @public
- * @param {runnerResult} runner 
+ * @return {q.promise} A promise which will resolve when the environment
+ *     is down.
  */
 HostedDriverProvider.prototype.teardownEnv = function(runner) {
-  var deferred = q.defer(),
-      passed = runner.results().failedCount === 0,
-      exitCode = passed ? 0 : 1;
-
-  deferred.resolve(exitCode);
+  var deferred = q.defer();
+  this.driver_.quit().then(function() {
+    deferred.resolve();
+  });
   return deferred.promise;
 };
 
 /**
- * getDriver is responsible for retrieving the webdriver for the runner.
+ * Return the webdriver for the runner.
  * @public
  * @return webdriver instance   
  */
 HostedDriverProvider.prototype.getDriver = function() {
   if (!this.driver_) {
     this.driver_ = new webdriver.Builder().
-    usingServer(this.trConfig_.seleniumHost).
-    withCapabilities(this.trConfig_.capabilities).build();
+        usingServer(this.config_.seleniumAddress).
+        withCapabilities(this.config_.capabilities).
+        build();
   }
   return this.driver_;
 };
 
-//new instance w/ each include
-module.exports = (function(testRunner) {
-  return new HostedDriverProvider(testRunner);
+// new instance w/ each include
+module.exports = (function(config) {
+  return new HostedDriverProvider(config);
 });
diff --git a/lib/driverProviders/local.dp.js b/lib/driverProviders/local.dp.js
index beeef8076..1557bf43f 100644
--- a/lib/driverProviders/local.dp.js
+++ b/lib/driverProviders/local.dp.js
@@ -1,9 +1,11 @@
 /*
- *  This is an implementation of the Local Driver Provider.
- *  It is responsible for setting up the account object, tearing
- *    it down, and setting up the driver correctly.
+ * This is an implementation of the Local Driver Provider.
+ * It is responsible for setting up the account object, tearing
+ * it down, and setting up the driver correctly.
+ *
+ * TODO - it would be nice to do this in the launcher phase,
+ * so that we only start the local selenium once per entire launch.
  */
-
 var util = require('util'),
     webdriver = require('selenium-webdriver'),
     path = require('path'),
@@ -11,104 +13,117 @@ var util = require('util'),
     fs = require('fs'),
     q = require('q');
 
-
-function LocalDriverProvider(testRunner) {
-
-  this.testRunner_ = testRunner;
-  this.trConfig_ = this.testRunner_.getConfig();
+var LocalDriverProvider = function(config) {
+  this.config_ = config;
   this.driver_ = null;
-}
+  this.server_ = null;
+};
 
 
 /**
- * helper to locate the default jar path if none is provided by the user
+ * Helper to locate the default jar path if none is provided by the user.
  * @private
  */
-LocalDriverProvider.prototype.locateDefaultJar_ = function() {
-  // Try to use the default location.
-  var defaultStandalone = path.resolve(__dirname,
-    '../../selenium/selenium-server-standalone-' +
-    require('../../package.json').webdriverVersions.selenium + '.jar');
-
-  if (!fs.existsSync(defaultStandalone)) {
-    throw new Error('Unable to start selenium. ' +
-      'You must specify either a seleniumAddress, ' +
-      'seleniumServerJar, or saucelabs account, or use webdriver-manager.');
+LocalDriverProvider.prototype.addDefaultBinaryLocs_ = function() {
+  if (!this.config_.seleniumServerJar) {
+    this.config_.seleniumServerJar = path.resolve(__dirname,
+        '../../selenium/selenium-server-standalone-' +
+        require('../../package.json').webdriverVersions.selenium + '.jar');
+  }
+  if (this.config_.capabilities.browserName === 'chrome') {
+    this.config_.chromeDriver = this.config_.chromeDriver ||
+        path.resolve(__dirname, '../../selenium/chromedriver');
+
+    // Check if file exists, if not try .exe or fail accordingly
+    if (!fs.existsSync(this.config_.chromeDriver)) {
+      this.config_.chromeDriver += '.exe';
+      // Throw error if the client specified conf chromedriver and its not found
+      if (!fs.existsSync(this.config_.chromeDriver)) {
+        throw new Error('Could not find chromedriver at ' +
+          this.config_.chromeDriver);
+      }
+    }
   }
-  return defaultStandalone;
 };
 
 /**
- * setupEnv is responsible for configuring and launching (if applicable)
- * the object's environment.
+ * Configure and launch (if applicable) the object's environment.
  * @public
- * @return promise
+ * @return {q.promise} A promise which will resolve when the environment is
+ *     ready to test.
  */
 LocalDriverProvider.prototype.setupEnv = function() {
   var deferred = q.defer(),
-    self = this;
+      self = this;
 
-  //if there's not already a jar file configured, try to resolve it
-  // - otherwise, confirm its existence
-  util.puts('Starting selenium standalone server...');
-  if (!this.trConfig_.seleniumLocal.jar) {
-    this.trConfig_.seleniumLocal.jar = this.locateDefaultJar_();
-  } else if (!fs.existsSync(this.trConfig_.seleniumLocal.jar)) {
+  this.addDefaultBinaryLocs_();
+  if (!fs.existsSync(this.config_.seleniumServerJar)) {
     throw new Error('there\'s no selenium server jar at the specified ' +
       'location. Do you have the correct version?');
   }
 
-  //configure server
-  if (this.trConfig_.chromeDriver) {
-    this.trConfig_.seleniumLocal.args.push('-Dwebdriver.chrome.driver=' +
-      this.trConfig_.chromeDriver);
+  util.puts('Starting selenium standalone server...');
+
+  // configure server
+  if (this.config_.chromeDriver) {
+    this.config_.seleniumArgs.push('-Dwebdriver.chrome.driver=' +
+      this.config_.chromeDriver);
   }
-  this.testRunner_._server = new remote.SeleniumServer(this.trConfig_.seleniumLocal.jar,
-    this.trConfig_.seleniumLocal);
+  this.server_ = new remote.SeleniumServer(this.config_.seleniumServerJar, {
+      args: this.config_.seleniumArgs,
+      port: this.config_.seleniumPort
+    });
 
   //start local server, grab hosted address, and resolve promise
-  this.testRunner_._server.start().then(function(url) {
+  this.server_.start().then(function(url) {
     util.puts('Selenium standalone server started at ' + url);
-    self._config.seleniumHost = self._server.address();
-    deferred.resolve(self._config.seleniumHost);
+    self.server_.address().then(function(address) {
+      self.config_.seleniumAddress = address;
+      deferred.resolve();
+    });
   });
 
   return deferred.promise;
 };
 
 /**
- * teardownEnv is responsible for destroying the environment and doing any
- * associated cleanup.
+ * Teardown and destroy the environment and do any associated cleanup.
+ * Shuts down the driver.
+ *
  * @public
- * @param {runnerResult} runner 
+ * @return {q.promise} A promise which will resolve when the environment
+ *     is down.
  */
-LocalDriverProvider.prototype.teardownEnv = function(runner) {
-  var deferred = q.defer(),
-      passed = runner.results().failedCount === 0,
-      exitCode = passed ? 0 : 1;
+LocalDriverProvider.prototype.teardownEnv = function() {
+  var deferred = q.defer();
+  var self = this;
 
   util.puts('Shutting down selenium standalone server.');
-  this.testRunner_._server.stop().bind(this.testRunner_).then(function() {
-    deferred.resolve(exitCode);
+  self.driver_.quit().then(function() {
+    return self.server_.stop().then(function() {
+      deferred.resolve();
+    });
   });
+
   return deferred.promise;
 };
 
 /**
- * getDriver is responsible for retrieving the webdriver for the runner.
+ * Retrieve the webdriver for the runner.
  * @public
- * @return webdriver instance   
+ * @return webdriver instance
  */
 LocalDriverProvider.prototype.getDriver = function() {
   if (!this.driver_) {
     this.driver_ = new webdriver.Builder().
-    usingServer(this.trConfig_.seleniumHost).
-    withCapabilities(this.trConfig_.capabilities).build();
+        usingServer(this.config_.seleniumAddress).
+        withCapabilities(this.config_.capabilities).
+        build();
   }
   return this.driver_;
 };
 
-//new instance w/ each include
-module.exports = (function(testRunner) {
-  return new LocalDriverProvider(testRunner);
+// new instance w/ each include
+module.exports = (function(config) {
+  return new LocalDriverProvider(config);
 });
diff --git a/lib/driverProviders/sauce.dp.js b/lib/driverProviders/sauce.dp.js
index 97c85a9ed..bf653c464 100644
--- a/lib/driverProviders/sauce.dp.js
+++ b/lib/driverProviders/sauce.dp.js
@@ -1,23 +1,21 @@
 /*
- *  This is an implementation of the Sauce Driver Provider.
- *  It is responsible for setting up the account object, tearing
- *    it down, and setting up the driver correctly.
+ * This is an implementation of the SauceLabs Driver Provider.
+ * It is responsible for setting up the account object, tearing
+ * it down, and setting up the driver correctly.
  */
 
 var util = require('util'),
     webdriver = require('selenium-webdriver'),
-    SauceLabs = require('saucelabs');
+    SauceLabs = require('saucelabs'),
     q = require('q');
 
 
-function SauceDriverProvider(testRunner) {
-
-  this.testRunner_ = testRunner;
-  this.trConfig_ = this.testRunner_.getConfig();
+var SauceDriverProvider = function(config) {
+  this.config_ = config;
   this.sauceServer_ = {};
   this.sessionId_ = null;
   this.driver_ = null;
-}
+};
 
 
 /**
@@ -29,65 +27,67 @@ SauceDriverProvider.prototype.setSession = function(session) {
 };
 
 /**
- * setupEnv is responsible for configuring and launching (if applicable)
- * the object's environment.
+ * Configure and launch (if applicable) the object's environment.
  * @public
+ * @return {q.promise} A promise which will resolve when the environment is
+ *     ready to test.
  */
 SauceDriverProvider.prototype.setupEnv = function() {
   var deferred = q.defer();
   this.sauceServer_ = new SauceLabs({
-    username: this.trConfig_.sauceAccount.user,
-    password: this.trConfig_.sauceAccount.key
+    username: this.config_.sauceUser,
+    password: this.config_.sauceKey
   });
-  this.trConfig_.capabilities.username = this.trConfig_.sauceAccount.user;
-  this.trConfig_.capabilities.accessKey = this.trConfig_.sauceAccount.key;
-  this.trConfig_.seleniumHost = 'http://' + this.trConfig_.sauceAccount.user + ':' +
-      this.trConfig_.sauceAccount.key + '@ondemand.saucelabs.com:80/wd/hub';
+  this.config_.capabilities.username = this.config_.sauceUser;
+  this.config_.capabilities.accessKey = this.config_.sauceKey;
+  this.config_.seleniumAddress = 'http://' + this.config_.sauceUser + ':' +
+      this.config_.sauceKey + '@ondemand.saucelabs.com:80/wd/hub';
 
   util.puts('Using SauceLabs selenium server at ' +
-      this.trConfig_.seleniumHost);
-  deferred.resolve(this.trConfig_.seleniumHost);
+      this.config_.seleniumAddress);
+  deferred.resolve();
   return deferred.promise;
 };
 
 /**
- * teardownEnv is responsible for destroying the environment and doing any
- * associated cleanup.
+ * Teardown and destroy the environment and do any associated cleanup.
+ * Shuts down the driver.
+ *
  * @public
- * @param {runnerResult} runner 
- * @return promise
+ * @return {q.promise} A promise which will resolve when the environment
+ *     is down.
  */
-SauceDriverProvider.prototype.teardownEnv = function(runner) {
-  var deferred = q.defer(),
-      passed = runner.results().failedCount === 0,
-      exitCode = passed ? 0 : 1;
+SauceDriverProvider.prototype.teardownEnv = function() {
+  var deferred = q.defer();
 
-  this.sauceServer_.updateJob(this.sessionId_, {'passed': passed}, function(err) {
+  // TODO figure out where this should live. DriverProvider shouldn't care
+  // about the state of the test.
+  this.sauceServer_.updateJob(this.sessionId_, {'passed': false}, function(err) {
     if (err) {
       throw new Error(
         'Error updating Sauce pass/fail status: ' + util.inspect(err)
       );
     }
-    deferred.resolve(exitCode);
+    deferred.resolve();
   });
   return deferred.promise;
 };
 
 /**
- * getDriver is responsible for retrieving the webdriver for the runner.
+ * Retrieve the webdriver for the runner.
  * @public
- * @return webdriver instance   
+ * @return webdriver instance
  */
 SauceDriverProvider.prototype.getDriver = function() {
   if (!this.driver_) {
     this.driver_ = new webdriver.Builder().
-    usingServer(this.trConfig_.seleniumHost).
-    withCapabilities(this.trConfig_.capabilities).build();
+        usingServer(this.config_.seleniumAddress).
+        withCapabilities(this.config_.capabilities).build();
   }
   return this.driver_;
 };
 
-//new instance w/ each include
-module.exports = (function(testRunner) {
-  return new SauceDriverProvider(testRunner);
+// new instance w/ each include
+module.exports = (function(config) {
+  return new SauceDriverProvider(config);
 });
diff --git a/lib/launcher.js b/lib/launcher.js
index fea97a0bc..cd5fce819 100644
--- a/lib/launcher.js
+++ b/lib/launcher.js
@@ -1,26 +1,32 @@
-'use strict';
+/**
+ * The launcher is responsible for parsing the capabilities from the
+ * input configuration and launching test runners.
+ */
+ 'use strict';
 
 var util = require('util'),
     path = require('path'),
     fs = require('fs'),
     glob = require('glob'),
     child = require('child_process'),
-    configParser = require('./configParser');
+    ConfigParser = require('./configParser');
 
 
-var reportHeader_ = function(proc,env) {
+var reportHeader_ = function(proc, env) {
   var capability = JSON.parse(env.capability);
   var eol = require('os').EOL;
 
-  var outputHeader = '------------------------------'+eol;
-  outputHeader += 'PID: '+proc.pid+' (capability: ';
+  var outputHeader = '------------------------------' + eol;
+  outputHeader += 'PID: ' + proc.pid + ' (capability: ';
   outputHeader += (capability.browserName) ?
       capability.browserName : '';
   outputHeader += (capability.version) ?
       capability.version : '';
   outputHeader += (capability.platform) ?
       capability.platform : '';
-  outputHeader += ')'+eol;
+  outputHeader += (env.runNumber) ?
+      ' #' + env.runNumber : '';
+  outputHeader += ')' + eol;
   outputHeader += '------------------------------';
 
 
@@ -28,90 +34,110 @@ var reportHeader_ = function(proc,env) {
 };
 
 /**
- * Responsible for handling an input of capabilities and launching the test runs
- * appropriate config values and scanning directories for specs
+ * Initialize and run the tests.
  *
  * @param {Object} argv - Optimist parsed arguments
  */
 var init = function(argv) {
 
-  var i, j, capabilityRunCount, childForks = [], config;
+  var capabilityRunCount,
+      childForks = [],
+      config,
+      launcherExitCode = 0;
 
-  // Merge in config file options
-  configParser.addFileConfig(argv._[0]);
-  configParser.addArgvConfig(argv);
-  config = configParser.getConfig();
+  config = new ConfigParser().
+      addFileConfig(argv._[0]).
+      addConfig(argv).
+      getConfig();
 
-  // Handle polymorphic param
-  if (!Array.isArray(config.capabilities)) {
-    config.capabilities = [config.capabilities];
+  // Merge 'capabilities' and 'multiCapabilities', if applicable.
+  if (!config.multiCapabilities.length) {
+    config.multiCapabilities = [config.capabilities];
   }
 
   // Loop through capabilities and launch forks of runner.js
-  for (i=0; i<config.capabilities.length; i++) {
+  for (var i = 0; i < config.multiCapabilities.length; i++) {
 
     // Determine how many times to run the capability
-    capabilityRunCount = (config.capabilities[i].count) ?
-        config.capabilities[i].count : 1;
+    capabilityRunCount = (config.multiCapabilities[i].count) ?
+        config.multiCapabilities[i].count : 1;
 
     // Fork the child runners.
-    for (j=0; j<capabilityRunCount; j++) {
+    for (var j = 0; j < capabilityRunCount; j++) {
 
       // We use an environment variable to retain the optimist parsed args and 
       // to tell the runner which capability its responsible for
       childForks.push({
-        optimistArgs: JSON.stringify(argv),
-        capability: JSON.stringify(config.capabilities[i])
+        cliArgs: JSON.stringify(argv),
+        capability: JSON.stringify(config.multiCapabilities[i]),
+        runNumber: j + 1
       });
     }
   }
 
   // If we're launching multiple runners, aggregate output until completion.
   // Otherwise, there are multiple runners, let's pipe the output straight
-  // through to maintain realtime reporting
-  if(childForks.length === 1) {
+  // through to maintain realtime reporting.
+  if (childForks.length === 1) {
     var childEnv = childForks.pop(),
-        childProc = child.fork(__dirname+"/runner.js", [], {env: childEnv});
+        childProc = child.fork(__dirname + "/runFromLauncher.js", [],
+            {env: childEnv,
+             cwd: process.cwd()});
     reportHeader_(childProc, childEnv);
-  }
-  else {
-    //Launch each fork and set up listeners
+    childProc.on('error', function(err) {
+      util.puts('Runner Process(' + childProc.pid + ') Error: ' + err);
+    });
+
+    childProc.on('exit', function(code, signal) {
+      if (code) {
+        util.puts('Runner Process Exited With Error Code: ' + code);
+        launcherExitCode = 1;
+      }
+    });
+  } else {
+    console.log('Running ' + childForks.length + ' instances of WebDriver...');
+
+    // Launch each fork and set up listeners
     childForks.forEach(function(childEnv) {
 
-      var childProc = child.fork(__dirname+"/runner.js", [],
-          {env: childEnv, silent: true});
+      var childProc = child.fork(__dirname + "/runFromLauncher.js", [],
+          {env: childEnv, silent: true, cwd: process.cwd()});
 
       // Force evaluation to protect from loop changing closure in callbacks
       (function(childProc_, childEnv_) {
-        childProc_._output = '';
+        childProc_.output = '';
 
         // stdin pipe
         childProc_.stdout.on('data', function(chunk) {
-          childProc_._output += chunk;
+          childProc_.output += chunk;
         });
 
         // stderr pipe
         childProc_.stderr.on('data', function(chunk) {
-          childProc_._output += chunk;
+          childProc_.output += chunk;
         });
 
         // err handler
         childProc_.on('error', function(err) {
-          util.puts('Runner Process('+childProc_.pid+') Error: '+err);
+          util.puts('Runner Process(' + childProc_.pid + ') Error: ' + err);
         });
 
-        // exit handler
-        childProc_.on('exit', function(code,signal) {
+        // exit handlers
+        childProc_.on('exit', function(code, signal) {
           if (code) {
-            util.puts('Runner Process Exited With Error Code: '+code);
+            util.puts('Runner Process Exited With Error Code: ' + code);
+            launcherExitCode = 1;
           }
-          reportHeader_(childProc_,childEnv_);
-          util.puts(childProc_._output);
+          reportHeader_(childProc_, childEnv_);
+          util.puts(childProc_.output);
         });
       })(childProc, childEnv);
-
     });
   }
+
+  process.on('exit', function(code) {
+    process.exit(launcherExitCode);
+  });
 };
 
 exports.init = init;
diff --git a/lib/runFromLauncher.js b/lib/runFromLauncher.js
new file mode 100644
index 000000000..268b15849
--- /dev/null
+++ b/lib/runFromLauncher.js
@@ -0,0 +1,32 @@
+/**
+ * This serves as the main function for starting a test run that has been
+ * requested by the launcher. It assumes that the process environment has
+ * been set with the following properties:
+ *   cliArgs - a stringified JSON object representing the CLI args passed
+ *             to this test run.
+ *   capability - a stringified JSON object representing the particular
+ *                capability to be used for this run.
+ *   numNumber - an identifier for this run, in case multiple runs of the same
+ *               capability were requested.
+ */
+
+var ConfigParser = require('./configParser');
+var Runner = require('./runner');
+
+var config, argv;
+
+// Merge in config file options.
+argv = JSON.parse(process.env.cliArgs);
+config = new ConfigParser().
+    addFileConfig(argv._[0]).
+    addConfig(argv).
+    getConfig();
+
+// Grab capability to run from launcher.
+config.capabilities = JSON.parse(process.env.capability);
+
+// Launch test run.
+var runner = new Runner(config);
+runner.run().then(function(exitCode) {
+  process.exit(exitCode);
+});
diff --git a/lib/runner.js b/lib/runner.js
index 4a4e77378..9df71341b 100644
--- a/lib/runner.js
+++ b/lib/runner.js
@@ -1,32 +1,363 @@
-var config,
-    configParser = require('./configParser');
+var protractor = require('./protractor'),
+    webdriver = require('selenium-webdriver'),
+    ConfigParser = require('./configParser'),
+    path = require('path'),
+    util = require('util'),
+    fs = require('fs'),
+    q = require('q');
 
+/*
+ * Runner is responsible for starting the execution of a test run and triggering
+ * setup, teardown, managing config, etc through its various dependencies.
+ *
+ * @param {Object} config
+ * @constructor
+ */
+var Runner = function(config) {
+  this.preparers_ = [];
+  this.driverprovider_ = null;
+  this.config_ = config;
 
-var init = function() {
+  // Init
+  this.loadDriverProvider_(config);
+}
 
-  // Launch test run
-  testRunner = require(__dirname+'/testRunner.js')(config);
 
-  // Register custom prep/cleanup jobs with testRunner
-  if (config.onPrepare) {
-    testRunner.registerTestPreparer(config.onPrepare);
+/**
+ * Execute the Runner's test cases through Jasmine.
+ *
+ * @private   
+ * @param {Array} specs Array of Directory Path Strings
+ * @param done A callback for when tests are finished.
+ */
+Runner.prototype.runJasmine_ = function(specs, done) {
+  var minijn = require('minijasminenode'),
+      self = this;
+  
+  require('../jasminewd');
+  webdriver.promise.controlFlow().execute(function() {
+    self.runTestPreparers_();
+  }).then(function() {
+    var jasmineNodeOpts = self.config_.jasmineNodeOpts;
+    var originalOnComplete = self.config_.onComplete;
+    jasmineNodeOpts.onComplete = function(runner, log) {
+      if (originalOnComplete) {
+        originalOnComplete(runner, log);
+      }
+      done(runner.results());
+    };
+
+    minijn.addSpecs(specs);
+    minijn.executeSpecs(jasmineNodeOpts);
+  });
+};
+
+
+/**
+ * Execute the Runner's test cases through Mocha.
+ *
+ * @private   
+ * @param {Array} specs Array of Directory Path Strings
+ * @param done A callback for when tests are finished.
+ */
+Runner.prototype.runMocha_ = function(specs, done) {
+
+  var Mocha = require('mocha'),
+      mocha = new Mocha(this.config_.mochaOpts),
+      self = this;
+
+
+  // Mocha doesn't set up the ui until the pre-require event, so
+  // wait until then to load mocha-webdriver adapters as well.
+  mocha.suite.on('pre-require', function() {
+    var mochaAdapters = require('selenium-webdriver/testing');
+    global.after = mochaAdapters.after;
+    global.afterEach = mochaAdapters.afterEach;
+    global.before = mochaAdapters.before;
+    global.beforeEach = mochaAdapters.beforeEach;
+
+    global.it = mochaAdapters.it;
+    global.it.only = global.iit = mochaAdapters.it.only;
+    global.it.skip = global.xit = mochaAdapters.xit;
+  });
+
+  mocha.loadFiles();
+
+  webdriver.promise.controlFlow().execute(function() {
+    self.runTestPreparers_();
+  }).then(function() {
+
+    specs.forEach(function(file) {
+      mocha.addFile(file);
+    });
+
+    mocha.run(function(failures) {
+      if (self.config_.onComplete) {
+        self.config_.onComplete();
+      }
+      var resolvedObj = {
+        failedCount: failures
+      };
+
+      done(resolvedObj);
+    });
+  });
+};
+
+/**
+ * Execute the Runner's test cases through Cucumber.
+ *
+ * @private   
+ * @param {Array} specs Array of Directory Path Strings
+ * @param done A callback for when tests are finished.
+ */
+Runner.prototype.runCucumber_ = function(specs, done) {
+  var Cucumber = require('cucumber'),
+      self = this,
+      execOptions = ['node', 'node_modules/.bin/cucumber-js'],
+      cucumberResolvedRequire;
+
+  // Set up exec options for Cucumber
+  execOptions = execOptions.concat(specs);
+  if (self.config_.cucumberOpts) {
+
+    // Process Cucumber Require param
+    if (self.config_.cucumberOpts.require) {
+      cucumberResolvedRequire =
+          ConfigParser.resolveFilePatterns(self.config_.cucumberOpts.require);
+      if (cucumberResolvedRequire && cucumberResolvedRequire.length) {
+          execOptions.push('-r');
+          execOptions = execOptions.concat(cucumberResolvedRequire);
+      }
+    }
+
+    // Process Cucumber Tag param
+    if (self.config_.cucumberOpts.tags) {
+      execOptions.push('-t');
+      execOptions.push(self.config_.cucumberOpts.tags);
+    }
+
+    // Process Cucumber Format param
+    if (self.config_.cucumberOpts.format) {
+      execOptions.push('-f');
+      execOptions.push(self.config_.cucumberOpts.format);
+    }
+  }
+  cucumber = Cucumber.Cli(execOptions);
+
+  webdriver.promise.controlFlow().execute(function() {
+    self.runTestPreparers_();
+  }).then(function() {
+
+    cucumber.run(function(succeeded) {
+      if (self.config_.onComplete) {
+        self.config_.onComplete();
+      }
+      var resolvedObj = {
+        failedCount: succeeded ? 0 : 1
+      };
+      done(resolvedObj);
+    });
+  });
+};
+
+
+/**
+ * Internal helper for abstraction of polymorphic filenameOrFn properties.
+ * @private   
+ * @param {Array} source The Array that we'll be iterating through
+ *    as we evaluate whether to require or execute each item.
+ */
+Runner.prototype.runFilenamesOrFns_ = function(source) {
+  var filenameOrFn;
+  for (var i = 0; i < source.length; i++) {
+    filenameOrFn = source[i];
+    if (filenameOrFn) {
+      if (typeof filenameOrFn === 'function') {
+        filenameOrFn();
+      } else if (typeof filenameOrFn === 'string') {
+        require(path.resolve(this.config_.configDir, filenameOrFn));
+      } else {
+        // TODO - this is not generic.
+        throw 'config.onPrepare must be a string or function';
+      }
+    }
+  }
+};
+
+
+/**
+ * Registrar for testPreparers - executed right before tests run.
+ * @public   
+ * @param {string/Fn} filenameOrFn
+ */
+Runner.prototype.registerTestPreparer = function(filenameOrFn) {
+  this.preparers_.push(filenameOrFn);
+};
+
+
+/**
+ * Executor of testPreparers
+ * @private   
+ */
+Runner.prototype.runTestPreparers_ = function() {
+  this.runFilenamesOrFns_(this.preparers_);
+};
+
+
+/**
+ * Grab driver provider based on type
+ * @private
+ *
+ * Priority
+ * 1) if chromeOnly, use that
+ * 2) if seleniumAddress is given, use that
+ * 3) if a sauceAccount is given, use that.
+ * 4) if a seleniumServerJar is specified, use that
+ * 5) try to find the seleniumServerJar in protractor/selenium   
+ */
+Runner.prototype.loadDriverProvider_ = function() {
+  var runnerPath;
+  if (this.config_.chromeOnly) {
+    runnerPath = './driverProviders/chrome.dp';
+  } else if (this.config_.seleniumAddress) {
+    runnerPath = './driverProviders/hosted.dp';
+  } else if (this.config_.sauceUser && userConfig.sauceKey) {
+    runnerPath = './driverProviders/sauce.dp';
+  } else if (this.config_.seleniumServerJar) {
+    runnerPath = './driverProviders/local.dp';
+  } else {
+    runnerPath = './driverProviders/local.dp';
   }
-  if (config.onCleanup) {
-    testRunner.registerTestCleaners(config.onCleanUp);
+
+  this.driverprovider_ = require(runnerPath)(this.config_);
+};
+
+
+/**
+ * Responsible for cleaning up test run and exiting the process.
+ * @private
+ * @param {int} Standard unix exit code
+ */
+Runner.prototype.exit_ = function(exitCode) {
+  if (typeof this.config_.onCleanUp === 'function') {
+    this.config_.onCleanUp(exitCode);
   }
+};
+
 
-  testRunner.run();
+/**
+ * Getter for the Runner config object
+ * @public
+ * @return {Object} config
+ */
+Runner.prototype.getConfig = function() {
+  return this.config_;
 };
 
 
-// Merge in config file options
-argv = JSON.parse(process.env.optimistArgs);
-configParser.addFileConfig(argv._[0]);
-configParser.addArgvConfig(argv);
-config = configParser.getConfig();
+/**
+ * Sets up convenience globals for test specs
+ * @private   
+ */
+Runner.prototype.setupGlobals_ = function(driver) {
+  var browser = protractor.wrapDriver(
+      driver,
+      this.config_.baseUrl,
+      this.config_.rootElement);
 
-//Grab capability to run from launcher
-config.capabilities = JSON.parse(process.env.capability);
+  browser.params = this.config_.params;
+  protractor.setInstance(browser);
 
-init();
+  // Export protractor to the global namespace to be used in tests.
+  global.protractor = protractor;
+  global.browser = browser;
+  global.$ = browser.$;
+  global.$$ = browser.$$;
+  global.element = browser.element;
+  global.by = global.By = protractor.By;
+};
+
+/**
+ * The primary workhorse interface. Kicks off the test running process.
+ *
+ * @public
+ */
+Runner.prototype.run = function() {
+  var self = this,
+      driver,
+      specs,
+      excludes,
+      testResult;
+
+  // Determine included and excluded specs based on file pattern.
+  excludes = ConfigParser.resolveFilePatterns(
+      this.config_.exclude, true, this.config_.configDir);
+  specs = ConfigParser.resolveFilePatterns(
+      this.config_.specs, false, this.config_.configDir).filter(function(path) {
+    return excludes.indexOf(path) < 0;
+  });
+
+  if (!specs.length) {
+    throw new Error('Spec patterns did not match any files.');
+  }
+
+  this.registerTestPreparer(this.config_.onPrepare);
+
+  // 1) Setup environment
+  return this.driverprovider_.setupEnv().then(function() {
+    driver = self.driverprovider_.getDriver();
+    return q.fcall(function() {});
+
+  // 2) Execute test cases
+  }).then(function() {
+
+    var deferred = q.defer();
+    driver.manage().timeouts().setScriptTimeout(self.config_.allScriptsTimeout);
+    self.setupGlobals_.bind(self)(driver);
+
+
+    // Do the framework setup here so that jasmine and mocha globals are
+    // available to the onPrepare function.
+    if (self.config_.framework === 'jasmine') {
+      self.runJasmine_.bind(self)(specs, function(result) {
+        deferred.resolve(result);
+      });
+    } else if (self.config_.framework === 'mocha') {
+      self.runMocha_.bind(self)(specs, function(result) {
+        deferred.resolve(result);
+      });
+    } else if (self.config_.framework === 'cucumber') {
+      self.runCucumber_.bind(self)(specs, function(result) {
+        deferred.resolve(result);
+      });
+    } else if (self.config_.framework === 'simpleprint') {
+      console.log('Resolved spec files ' + util.inspect(specs));
+      deferred.resolve({failedCount: 0});
+    } else {
+      throw new Error('config.framework (' + self.config_.framework +
+          ') is not a valid framework.');
+    }
+    
+    return deferred.promise;
+
+  // 3) Teardown
+  }).then(function(result) {
+    testResult = result;
+    return self.driverprovider_.teardownEnv();
+  // 4) Exit process
+  }).then(function() {
+    var passed = testResult.failedCount === 0;
+    var exitCode = passed ? 0 : 1;
+    self.exit_(exitCode);
+    return exitCode;
+  });
+};
 
+/**
+ * Creates and returns a Runner instance
+ *
+ * @public
+ * @param {Object} config
+ */
+module.exports = Runner;
diff --git a/lib/testRunner.js b/lib/testRunner.js
deleted file mode 100644
index c40233da5..000000000
--- a/lib/testRunner.js
+++ /dev/null
@@ -1,456 +0,0 @@
-var protractor = require(__dirname+'/protractor.js'),
-    webdriver = require('selenium-webdriver'),
-    configParser = require(__dirname+'/configParser'),
-    path = require('path'),
-    util = require('util'),
-    fs = require('fs'),
-    q = require('q');
-
-/*
- * This object serves as the primarily responsible party for starting the
- * execution of a test run and triggering setup, teardown, managing config,
- * etc through its various dependencies.
- */
-function TestRunner(config) {
-
-  this.config_= {
-    specs: [],
-    capabilities: {
-      browserName: 'chrome'
-    },
-    seleniumHost: 'http://localhost:4444/wd/hub',
-    rootElement: 'body',
-    baseUrl: 'http://localhost',
-    timeout: 11000,
-    browserParams: {},
-    framework: 'jasmine',
-    jasmineOpts: {
-      isVerbose: false,
-      showColors: true,
-      includeStackTrace: true,
-      stackFilter: protractor.filterStackTrace,
-      defaultTimeoutInterval: (30 * 1000)
-    },
-    cucumberOpts: {},
-    mochaOpts: {
-      ui: 'bdd',
-      reporter: 'list'
-    },
-    seleniumLocal: {
-      jar: null,
-      args: [],
-      port: null
-    },
-    sauceAccount: {},
-    chromeDriver: null,
-    configDir: './'
-  };
-
-  //properties set up internally
-  this.preparers_ = [];
-  this.cleaners_ = [];
-  this.driverprovider_ = undefined;
-
-  // Init
-  configParser.loadConfig(this.config_,config);
-  this.loadDriverProvider_(config);
-}
-
-
-/**
- * Sets up chromeDriver property.  Attempts to locate a default 
- * if none is provided
- * @private   
- */
-TestRunner.prototype.setupChromeDriver_ = function() {
-  var defaultChromedriver,
-    userSpecified = !!(this.config_.chromeDriver);
-
-  //use default if none was provided
-  defaultChromedriver = (this.config_.chromeDriver) ?
-      this.config_.chromeDriver :
-      path.resolve(__dirname,'../../selenium/chromedriver');
-
-  //check if file exists, if not try .exe or fail accordingly
-  if (!fs.existsSync(defaultChromedriver)) {
-    
-    defaultChromedriver+='.exe';
-    //throw error if the client specified conf chromedriver and its not found
-    if (!fs.existsSync(defaultChromedriver) && userSpecified) {
-      throw new Error('Could not find chromedriver at ' +
-        defaultChromedriver);
-    }
-  }
-  this.config_.chromeDriver = defaultChromedriver;
-};
-
-
-/**
- * Responsible for executing the testRunner's test cases through Jasmine
- * @private   
- * @param {Array} specs - Array of Directory Path Strings
- * @param deferred - the deferred object that we're going to resolve when
- *    Jasmine is done
- */
-TestRunner.prototype.runJasmine_ = function(specs, callbackFn) {
-
-  //jasmine setup
-  var minijn = require('minijasminenode'),
-      self = this;
-  
-  //inject on complete within flow and handle jasmine execution
-  require('../jasminewd');
-  webdriver.promise.controlFlow().execute(function() {
-    self.runTestPreparers_();
-  }).then(function() {
-    var opt = self.config_.jasmineOpts;
-    opt._originalOnComplete = self.config_.onComplete;
-    opt.onComplete = function(runner, log) {
-      if (opt._originalOnComplete) {
-        opt._originalOnComplete(runner, log);
-      }
-      callbackFn(runner);
-    };
-
-    minijn.addSpecs(specs);
-    minijn.executeSpecs(opt);
-  });
-};
-
-
-/**
- * Responsible for executing the testRunner's test cases through Mocha
- * @private   
- * @param {Array} specs - Array of Directory Path Strings
- * @param deferred - the deferred object that we're going to resolve
- *    when Mocha is done
- */
-TestRunner.prototype.runMocha_ = function(specs, callbackFn) {
-
-  var Mocha = require('mocha'),
-      mocha = new Mocha(this.config_.mochaOpts),
-      self = this;
-
-
-  // Mocha doesn't set up the ui until the pre-require event, so
-  // wait until then to load mocha-webdriver adapters as well.
-  mocha.suite.on('pre-require', function() {
-    var mochaAdapters = require('selenium-webdriver/testing');
-    global.after = mochaAdapters.after;
-    global.afterEach = mochaAdapters.afterEach;
-    global.before = mochaAdapters.before;
-    global.beforeEach = mochaAdapters.beforeEach;
-
-    global.it = mochaAdapters.it;
-    global.it.only = global.iit = mochaAdapters.it.only;
-    global.it.skip = global.xit = mochaAdapters.xit;
-  });
-
-  mocha.loadFiles();
-
-  webdriver.promise.controlFlow().execute(function() {
-    self.runTestPreparers_();
-  }).then(function() {
-
-    specs.forEach(function(file) {
-      mocha.addFile(file);
-    });
-
-    mocha.run(function(failures) {
-      if (self.config_.onComplete) {
-        self.config_.onComplete();
-      }
-      var resolvedObj = {
-        results: function() {
-          return {
-            failedCount: failures
-          };
-        }
-      };
-
-      self.driverprovider_.getDriver().quit().then(function() {
-        callbackFn(resolvedObj);
-      });
-    });
-  });
-};
-
-
-TestRunner.prototype.runCucumber_ = function(specs, callbackFn) {
-  var Cucumber = require('cucumber'),
-      self = this,
-      execOptions = ['node', 'node_modules/.bin/cucumber-js'],
-      cucumberResolvedRequire;
-
-  //Set up exec options for Cucumber
-  execOptions = execOptions.concat(specs);
-  if (self.config_.cucumberOpts) {
-
-    //Process Cucumber Require param
-    if (self.config_.cucumberOpts.require) {
-      cucumberResolvedRequire =
-          configParser.resolveFilePatterns(self.config_.cucumberOpts.require);
-      if (cucumberResolvedRequire && cucumberResolvedRequire.length) {
-          execOptions.push('-r');
-          execOptions = execOptions.concat(cucumberResolvedRequire);
-      }
-    }
-
-    //Process Cucumber Tag param
-    if (self.config_.cucumberOpts.tags) {
-      execOptions.push('-t');
-      execOptions.push(self.config_.cucumberOpts.tags);
-    }
-
-    //Process Cucumber Format param
-    if (self.config_.cucumberOpts.format) {
-      execOptions.push('-f');
-      execOptions.push(self.config_.cucumberOpts.format);
-    }
-  }
-  cucumber = Cucumber.Cli(execOptions);
-
-  webdriver.promise.controlFlow().execute(function() {
-    self.runTestPreparers_();
-  }).then(function() {
-
-    cucumber.run(function(succeeded) {
-      if (self.config_.onComplete) {
-        self.config_.onComplete();
-      }
-      var resolvedObj = {
-        results: function() {
-          return {
-            failedCount: succeeded ? 0 : 1
-          };
-        }
-      };
-      self.driverprovider_.getDriver().quit().then(function() {
-        callbackFn(resolvedObj);
-      });
-    });
-  });
-};
-
-
-/**
- * Internal helper for abstraction of polymorphic filenameOrFn properties
- * @private   
- * @param {Array} source - the Object Array that we'll be iterating through
- *    as we evaluate whether to require or execute each item.
- */
-TestRunner.prototype.runFilenameOrFn_ = function(source) {
-  var i, filenameOrFn;
-  for (i=0; i<source.length; i++) {
-    filenameOrFn = source[i];
-    if (typeof filenameOrFn === 'function') {
-      filenameOrFn();
-    } else if (typeof filenameOrFn === 'string') {
-      require(path.resolve(this.config_.configDir, filenameOrFn));
-    } else {
-      throw 'config.onPrepare must be a string or function';
-    }
-  }
-};
-
-
-/**
- * Registrar for testPreparers - executed right before tests run.
- * @public   
- * @param {string/Fn} filenameOrFn
- */
-TestRunner.prototype.registerTestPreparer = function(filenameOrFn) {
-  this.preparers_.push(filenameOrFn);
-};
-
-
-/**
- * Executor of testPreparers
- * @private   
- */
-TestRunner.prototype.runTestPreparers_ = function() {
-  this.runFilenameOrFn_(this.preparers_);
-};
-
-
-/**
- * Registrar for testCleaners - executed right after tests run.
- * @public
- * @param {string/Fn} filenameOrFn
- */
-TestRunner.prototype.registerTestCleaners = function(filenameOrFn) {
-  this.cleaners_.push(filenameOrFn);
-};
-
-
-/**
- * Executor of testCleaners
- * @private   
- */
-TestRunner.prototype.runTestCleaners_ = function() {
-  this.runFilenameOrFn_(this.cleaners_);
-};
-
-
-/**
- * Grab driver provider based on type
- * @private   
- *
- * Priority
- * 1) if chromeOnly, use that
- * 2) if seleniumAddress is given, use that
- * 3) if a sauceAccount is given, use that.
- * 4) if a seleniumServerJar is specified, use that
- * 5) try to find the seleniumServerJar in protractor/selenium   
- */
-TestRunner.prototype.loadDriverProvider_ = function(userConfig) {
-  if (userConfig.chromeOnly) {
-    testRunnerPath = __dirname+'/driverProviders/chrome.dp';
-  }
-  else if (userConfig.seleniumAddress) {
-    testRunnerPath = __dirname+'/driverProviders/hosted.dp';
-  }
-  else if (userConfig.sauceUser && userConfig.sauceKey) {
-    testRunnerPath = __dirname+'/driverProviders/sauce.dp';
-  }
-  else if (userConfig.seleniumServerJar) {
-    testRunnerPath = __dirname+'/driverProviders/local.dp';
-  }
-  else {
-    testRunnerPath = __dirname+'/driverProviders/local.dp';
-  }
-
-  this.driverprovider_ = require(testRunnerPath)(this);
-};
-
-
-/**
- * Responsible for cleaning up test run and exiting the process.
- * @private
- * @param {int} Standard unix exit code
- */
-TestRunner.prototype.exit_ = function(exitCode) {
-  if (typeof config.onCleanUp === 'function') {
-    config.onCleanUp(exitCode);
-  }
-  process.exit(exitCode);
-};
-
-
-/**
- * Getter for the testRunner config object
- * @public
- * @return {Object} config
- */
-TestRunner.prototype.getConfig = function() {
-  return this.config_;
-};
-
-
-/**
- * Sets up convenience globals for test specs
- * @private   
- */
-TestRunner.prototype.setupGlobals_ = function(driver) {
-  var globalEnv = {},
-      browser = protractor.wrapDriver(
-          driver,
-          this.config_.baseUrl,
-          this.config_.rootElement);
-
-  browser.params = this.config_.browserParams;
-  protractor.setInstance(browser);
-
-  // Export protractor to the global namespace to be used in tests.
-  global.protractor = protractor;
-  global.browser = browser;
-  global.$ = browser.$;
-  global.$$ = browser.$$;
-  global.element = browser.element;
-  global.by = global.By = protractor.By;
-};
-
-/**
- * The primary workhorse interface.  Kicks off the test running process.
- * This method is responsible for setting up and tearing down the test
- * environments as well as kicking of child test processes as necessary.
- * @public
- */
-TestRunner.prototype.run = function() {
-
-  var self = this,
-      driver = {},
-      specs,
-      excludes;
-
-
-  // Determine included and excluded specs based on file pattern
-  excludes = configParser.resolveFilePatterns(this.config_.exclude, true);
-  specs = configParser.resolveFilePatterns(this.config_.specs).filter(function (path) {
-      return excludes.indexOf(path) < 0;
-  });
-  if (!specs.length) {
-      throw new Error('Spec patterns did not match any files.');
-  }
-
-  //1) Setup environment
-  this.driverprovider_.setupEnv().then(function() {
-    driver = self.driverprovider_.getDriver();
-    return driver.getSession();
-
-  //2) Execute test cases
-  }).fail(function() { /*allow exceptions*/ }).then(function(session) {
-    var deferred = q.defer();
-
-    //set timeout for the current script
-    driver.manage().timeouts().setScriptTimeout(self.config_.timeout);
-
-    //capture session id and setup globals
-    if (self.driverprovider_.setSession) {
-      self.driverprovider_.setSession(session);
-    }
-
-    self.setupGlobals_.bind(self)(driver);
-    self.setupChromeDriver_();
-
-    // Do the framework setup here so that jasmine and mocha globals are
-    // available to the onPrepare function.
-    if (self.config_.framework === 'jasmine') {
-      self.runJasmine_.bind(self)(specs, function(runner){
-        driver.quit().then(function() {
-          deferred.resolve(runner);
-        });
-      });
-    } else if (self.config_.framework === 'mocha') {
-      self.runMocha_.bind(self)(specs, function(resolvedObj) {
-        deferred.resolve(resolvedObj);
-      });
-    } else if (self.config_.framework === 'cucumber') {
-      self.runCucumber_.bind(self)(specs, function(resolvedObj) {
-        deferred.resolve(resolvedObj);
-      });
-    } else {
-      throw new Error('config.framework ' + self.config_.framework +
-          ' is not a valid framework.');
-    }
-    
-    return deferred.promise;
-
-  //3) Teardown
-  }).fail(function() { /*allow exceptions*/ }).then(function(result) {
-    return this.driverprovider_.teardownEnv(result);
-  //4) Exit process
-  }).fail(function() { /*allow exceptions*/ }).then(function(exitCode) {
-    this.exit_(exitCode);
-  });
-};
-
-/**
- * Creates and returns a TestRunner instance
- *
- * @public
- * @param {Object} config
- */
-module.exports = (function(config) {
-  return new TestRunner(config);
-});
diff --git a/spec/basicConf.js b/spec/basicConf.js
index cbdd128f5..c9e070d03 100644
--- a/spec/basicConf.js
+++ b/spec/basicConf.js
@@ -12,6 +12,8 @@ exports.config = {
     'basic/exclude*.js'
   ],
 
+  chromeOnly: false,
+
   capabilities: {
     'browserName': 'chrome'
   },
diff --git a/spec/driverprovider_test.js b/spec/driverprovider_test.js
new file mode 100644
index 000000000..ee58bce98
--- /dev/null
+++ b/spec/driverprovider_test.js
@@ -0,0 +1,86 @@
+/**
+ * Sanity integration tests for Driver Providers.
+ *
+ * Assumed setup:
+ * - selenium server running locally at http://localhost:4444
+ * - selenium jar and chromedriver in protractor/selenium, where
+ *   webdriver-manager stores them.
+ * - if you want to test saucelabs, test with --sauceUser and --sauceKey
+ *
+ * You should verify that there are no lingering processes when these tests
+ * complete.
+ */
+
+var argv = require('optimist').argv;
+var q = require('q');
+
+var testDriverProvider = function(driverProvider) {
+  return driverProvider.setupEnv().then(function() {
+    var driver = driverProvider.getDriver();
+    var deferred = q.defer();
+    driver.get('about:blank');
+    driver.getCurrentUrl().then(function(url) {
+      if (url != 'about:blank') {
+        throw new Error ('url was not about:blank, instead found ' + url);
+      }
+      deferred.resolve();
+    });
+    return deferred.promise;
+  }).then(function() {
+    driverProvider.teardownEnv();
+  });
+};
+
+var chromeConfig = {
+  capabilities: {
+    browserName: 'chrome'
+  }
+}
+testDriverProvider(require('../lib/driverProviders/chrome.dp')(chromeConfig)).
+    then(function() {
+      console.log('chrome.dp working!');
+    }, function(err) {
+      console.log('chrome.dp failed with ' + err);
+    });
+
+var hostedConfig = {
+  sauceAddress: 'http://localhost:4444/wd/hub',
+  capabilities: {
+    browserName: 'firefox'
+  }
+}
+testDriverProvider(require('../lib/driverProviders/hosted.dp')(hostedConfig)).
+    then(function() {
+      console.log('hosted.dp working!');
+    }, function(err) {
+      console.log('hosted.dp failed with ' + err);
+    });
+
+var localConfig = {
+  seleniumArgs: [],
+  capabilities: {
+    browserName: 'chrome'
+  }
+}
+testDriverProvider(require('../lib/driverProviders/local.dp')(localConfig)).
+    then(function() {
+      console.log('local.dp working!');
+    }, function(err) {
+      console.log('local.dp failed with ' + err);
+    });
+
+if (argv.sauceUser && argv.sauceKey) {
+  var sauceConfig = {
+    sauceUser: argv.sauceUser,
+    sauceKey: argv.sauceKey,
+    capabilities: {
+      browserName: 'chrome'
+    }
+  }
+  testDriverProvider(require('../lib/driverProviders/sauce.dp')(sauceConfig)).
+      then(function() {
+        console.log('sauce.dp working!');
+      }, function(err) {
+        console.log('sauce.dp failed with ' + err);
+      });
+}
diff --git a/spec/unit/config_test.js b/spec/unit/config_test.js
new file mode 100644
index 000000000..e6e3016f6
--- /dev/null
+++ b/spec/unit/config_test.js
@@ -0,0 +1,65 @@
+var ConfigParser = require('../../lib/configParser');
+var path = require('path');
+
+describe('the config parser', function() {
+  it('should have a default config', function() {
+    var config = new ConfigParser().getConfig();
+    expect(config.specs).toEqual([]);
+    expect(config.rootElement).toEqual('body');
+  });
+
+  it('should merge in config from an object', function() {
+    var toAdd = {
+      rootElement: '.mydiv'
+    }
+    var config = new ConfigParser().addConfig(toAdd).getConfig();
+    expect(config.specs).toEqual([]);
+    expect(config.rootElement).toEqual('.mydiv');
+  });
+
+  it('should merge in config from a file', function() {
+    var config = new ConfigParser().
+        addFileConfig(__dirname + '/data/config.js').
+        getConfig();
+
+    expect(config.rootElement).toEqual('.mycontainer');
+    expect(config.onPrepare).toMatch('/spec/unit/data/foo/bar.js');
+    expect(config.specs.length).toEqual(1);
+    expect(config.specs[0]).toEqual('fakespec*.js');
+  });
+
+  it('should keep filepaths relative to the cwd when merging', function() {
+    var toAdd = {
+      onPrepare: 'baz/qux.js'
+    }
+
+    var config = new ConfigParser().addConfig(toAdd).getConfig();
+
+    expect(config.onPrepare).toEqual(process.cwd() + '/baz/qux.js');
+  });
+
+  describe('resolving globs', function() {
+    it('should resolve relative to the cwd', function() {
+      spyOn(process, 'cwd').andReturn(__dirname + '/');
+      var toAdd = {
+        specs: 'data/*spec*.js'
+      }
+      var config = new ConfigParser().addConfig(toAdd).getConfig();
+      var specs = ConfigParser.resolveFilePatterns(config.specs);
+      expect(specs.length).toEqual(2);
+      expect(specs[0]).toMatch('unit/data/fakespecA.js');
+      expect(specs[1]).toMatch('unit/data/fakespecB.js');
+    });
+
+    it('should resolve relative to the config file dir', function() {
+      var config = new ConfigParser().
+          addFileConfig(__dirname + '/data/config.js').
+          getConfig();
+      var specs = ConfigParser.resolveFilePatterns(
+          config.specs, false, config.configDir);
+      expect(specs.length).toEqual(2);
+      expect(specs[0]).toMatch('unit/data/fakespecA.js');
+      expect(specs[1]).toMatch('unit/data/fakespecB.js');
+    });
+  });
+});
diff --git a/spec/unit/data/config.js b/spec/unit/data/config.js
new file mode 100644
index 000000000..49dc04ac4
--- /dev/null
+++ b/spec/unit/data/config.js
@@ -0,0 +1,5 @@
+exports.config = {
+  onPrepare: 'foo/bar.js',
+  specs: [ 'fakespec*.js' ],
+  rootElement: '.mycontainer'
+}
diff --git a/spec/unit/data/fakespecA.js b/spec/unit/data/fakespecA.js
new file mode 100644
index 000000000..f87af3c19
--- /dev/null
+++ b/spec/unit/data/fakespecA.js
@@ -0,0 +1 @@
+// Blank
diff --git a/spec/unit/data/fakespecB.js b/spec/unit/data/fakespecB.js
new file mode 100644
index 000000000..f87af3c19
--- /dev/null
+++ b/spec/unit/data/fakespecB.js
@@ -0,0 +1 @@
+// Blank
diff --git a/spec/unit/runner_test.js b/spec/unit/runner_test.js
new file mode 100644
index 000000000..ac52e9952
--- /dev/null
+++ b/spec/unit/runner_test.js
@@ -0,0 +1,84 @@
+var Runner = require('../../lib/runner');
+var q = require('q');
+
+describe('the Protractor runner', function() {
+  var mockDriverProvider;
+
+  beforeEach(function() {
+    mockDriverProvider = jasmine.createSpyObj(
+        'mockDriverProvider',
+        ['setupEnv', 'teardownEnv', 'getDriver']);
+
+    mockDriverProvider.setupEnv.andCallFake(function() {
+      return q.fcall(function() {});
+    });
+
+    mockDriverProvider.teardownEnv.andCallFake(function() {
+      return q.fcall(function() {});
+    });
+
+    mockDriverProvider.getDriver.andReturn({
+      // A fake driver.
+      manage: function() {
+        return {
+          timeouts: function() {
+            return {
+              setScriptTimeout: function() {}
+            };
+          }
+        };
+      }
+    });
+  });
+
+  it('should export its config', function() {
+    var config = {
+      foo: 'bar',
+    };
+
+    var runner = new Runner(config);
+
+    expect(runner.getConfig()).toEqual(config);
+  });
+
+  it('should run', function(done) {
+    var config = {
+      specs: ['*.js'],
+      framework: 'simpleprint'
+    };
+    var exitCode;
+    Runner.prototype.loadDriverProvider_ = function() {
+      this.driverprovider_ = mockDriverProvider;
+    };
+    Runner.prototype.exit_ = function(exit) {
+      exitCode = exit;
+    };
+    var runner = new Runner(config);
+
+    runner.run().then(function() {
+      expect(mockDriverProvider.setupEnv).toHaveBeenCalled();
+      expect(mockDriverProvider.teardownEnv).toHaveBeenCalled();
+      expect(exitCode).toEqual(0);
+      done();
+    });
+  });
+
+  it('should fail with no specs', function() {
+    var config = {
+      specs: [],
+      framework: 'simpleprint'
+    };
+    var exitCode;
+    Runner.prototype.loadDriverProvider_ = function() {
+      this.driverprovider_ = mockDriverProvider;
+    };
+    Runner.prototype.exit_ = function(exit) {
+      exitCode = exit;
+    };
+    var runner = new Runner(config);
+
+    expect(function() {
+      runner.run()
+    }).toThrow();
+  });
+});