[js] Defer wrapping the global mocha functions until first use

This prevents a potential reference error when users run with a --hook
that loads `selenium-webriver/testing`. This creates a cycle with mocha
and the expected globals won't exist when the module runs.

Also adding logic to fail with a more informative message when the
expected globals are not present.

Fixes #2787

Author: jleyba

javascript/node/selenium-webdriver/CHANGES.md

@@ -6,6 +6,9 @@
 
   To use Safari 9 or older, users will have to use an older version of Selenium.
 
+* Fixed potential reference errors in `selenium-webdriver/testing` when users
+  create a cycle with mocha by running with mocha's `--hook` flag.
+
 
 ### API Changes
 

javascript/node/selenium-webdriver/testing/index.js

@@ -66,6 +66,8 @@
  *     function maybe() { return Math.random() < 0.5; }
  */
 
+'use strict';
+
 var promise = require('..').promise;
 var flow = promise.controlFlow();
 
@@ -196,6 +198,45 @@ function ignore(predicateFn) {
 }
 
 
+/**
+ * @param {string} name
+ * @return {!Function}
+ * @throws {TypeError}
+ */
+function getMochaGlobal(name) {
+  let fn = global[name];
+  let type = typeof fn;
+  if (type !== 'function') {
+    throw TypeError(
+        `Expected global.${name} to be a function, but is ${type}. `
+            + 'This can happen if you try using this module when running '
+            + 'with node directly instead of using the mocha executable');
+  }
+  return fn;
+}
+
+
+const WRAPPED = {
+  after: null,
+  afterEach: null,
+  before: null,
+  beforeEach: null,
+  it: null,
+  itOnly: null,
+  xit: null
+};
+
+
+function wrapIt() {
+  if (!WRAPPED.it) {
+    let it = getMochaGlobal('it');
+    WRAPPED.it = wrapped(it);
+    WRAPPED.itOnly = wrapped(it.only);
+  }
+}
+
+
+
 // PUBLIC API
 
 
@@ -211,67 +252,134 @@ exports.controlFlow = function(){
 /**
  * Registers a new test suite.
  * @param {string} name The suite name.
- * @param {function()=} fn The suite function, or {@code undefined} to define
+ * @param {function()=} opt_fn The suite function, or `undefined` to define
+ *     a pending test suite.
+ */
+exports.describe = function(name, opt_fn) {
+  let fn = getMochaGlobal('describe');
+  return opt_fn ? fn(name, opt_fn) : fn(name);
+};
+
+
+/**
+ * Defines a suppressed test suite.
+ * @param {string} name The suite name.
+ * @param {function()=} opt_fn The suite function, or `undefined` to define
  *     a pending test suite.
  */
-exports.describe = global.describe;
+exports.describe.skip = function(name, opt_fn) {
+  let fn = getMochaGlobal('describe');
+  return opt_fn ? fn.skip(name, opt_fn) : fn.skip(name);
+};
+
 
 /**
  * Defines a suppressed test suite.
  * @param {string} name The suite name.
- * @param {function()=} fn The suite function, or {@code undefined} to define
+ * @param {function()=} opt_fn The suite function, or `undefined` to define
  *     a pending test suite.
  */
-exports.xdescribe = global.xdescribe;
-exports.describe.skip = global.describe.skip;
+exports.xdescribe = function(name, opt_fn) {
+  let fn = getMochaGlobal('xdescribe');
+  return opt_fn ? fn(name, opt_fn) : fn(name);
+};
+
 
 /**
  * Register a function to call after the current suite finishes.
  * @param {function()} fn .
  */
-exports.after = wrapped(global.after);
+exports.after = function(fn) {
+  if (!WRAPPED.after) {
+    WRAPPED.after = wrapped(getMochaGlobal('after'));
+  }
+  WRAPPED.after(fn);
+};
+
 
 /**
  * Register a function to call after each test in a suite.
  * @param {function()} fn .
  */
-exports.afterEach = wrapped(global.afterEach);
+exports.afterEach = function(fn) {
+  if (!WRAPPED.afterEach) {
+    WRAPPED.afterEach = wrapped(getMochaGlobal('afterEach'));
+  }
+  WRAPPED.afterEach(fn);
+};
+
 
 /**
  * Register a function to call before the current suite starts.
  * @param {function()} fn .
  */
-exports.before = wrapped(global.before);
+exports.before = function(fn) {
+  if (!WRAPPED.before) {
+    WRAPPED.before = wrapped(getMochaGlobal('before'));
+  }
+  WRAPPED.before(fn);
+};
 
 /**
  * Register a function to call before each test in a suite.
  * @param {function()} fn .
  */
-exports.beforeEach = wrapped(global.beforeEach);
+exports.beforeEach = function(fn) {
+  if (!WRAPPED.beforeEach) {
+    WRAPPED.beforeEach = wrapped(getMochaGlobal('beforeEach'));
+  }
+  WRAPPED.beforeEach(fn);
+};
 
 /**
  * Add a test to the current suite.
  * @param {string} name The test name.
- * @param {function()=} fn The test function, or {@code undefined} to define
+ * @param {function()=} opt_fn The test function, or `undefined` to define
  *     a pending test case.
  */
-exports.it = wrapped(global.it);
+exports.it = function(name, opt_fn) {
+  wrapIt();
+  if (opt_fn) {
+    WRAPPED.it(name, opt_fn);
+  } else {
+    WRAPPED.it(name);
+  }
+};
 
 /**
  * An alias for {@link #it()} that flags the test as the only one that should
  * be run within the current suite.
  * @param {string} name The test name.
- * @param {function()=} fn The test function, or {@code undefined} to define
+ * @param {function()=} opt_fn The test function, or `undefined` to define
  *     a pending test case.
  */
-exports.iit = exports.it.only = wrapped(global.it.only);
+exports.it.only = function(name, opt_fn) {
+  wrapIt();
+  if (opt_fn) {
+    WRAPPED.itOnly(name, opt_fn);
+  } else {
+    WRAPPED.itOnly(name);
+  }
+};
+
 
 /**
  * Adds a test to the current suite while suppressing it so it is not run.
  * @param {string} name The test name.
- * @param {function()=} fn The test function, or {@code undefined} to define
+ * @param {function()=} opt_fn The test function, or `undefined` to define
  *     a pending test case.
  */
-exports.xit = exports.it.skip = wrapped(global.xit);
+exports.xit = function(name, opt_fn) {
+  if (!WRAPPED.xit) {
+    WRAPPED.xit = wrapped(getMochaGlobal('xit'));
+  }
+  if (opt_fn) {
+    WRAPPED.xit(name, opt_fn);
+  } else {
+    WRAPPED.xit(name);
+  }
+};
+
 
+exports.it.skip = exports.xit;
 exports.ignore = ignore;