selenium-webdriver 2.48.2 → 2.52.0

package/lib/goog/testing/mockcontrol.js

@@ -1,220 +0,0 @@
-// Copyright 2008 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @fileoverview A MockControl holds a set of mocks for a particular test.
- * It consolidates calls to $replay, $verify, and $tearDown, which simplifies
- * the test and helps avoid omissions.
- *
- * You can create and control a mock:
- *   var mockFoo = mockControl.addMock(new MyMock(Foo));
- *
- * MockControl also exposes some convenience functions that create
- * controlled mocks for common mocks: StrictMock, LooseMock,
- * FunctionMock, MethodMock, and GlobalFunctionMock.
- *
- */
-
-
-goog.provide('goog.testing.MockControl');
-
-goog.require('goog.array');
-goog.require('goog.testing');
-goog.require('goog.testing.LooseMock');
-goog.require('goog.testing.StrictMock');
-
-
-
-/**
- * Controls a set of mocks.  Controlled mocks are replayed, verified, and
- * cleaned-up at the same time.
- * @constructor
- */
-goog.testing.MockControl = function() {
-  /**
-   * The list of mocks being controlled.
-   * @type {Array<goog.testing.MockInterface>}
-   * @private
-   */
-  this.mocks_ = [];
-};
-
-
-/**
- * Takes control of this mock.
- * @param {goog.testing.MockInterface} mock Mock to be controlled.
- * @return {goog.testing.MockInterface} The same mock passed in,
- *     for convenience.
- */
-goog.testing.MockControl.prototype.addMock = function(mock) {
-  this.mocks_.push(mock);
-  return mock;
-};
-
-
-/**
- * Calls replay on each controlled mock.
- */
-goog.testing.MockControl.prototype.$replayAll = function() {
-  goog.array.forEach(this.mocks_, function(m) {
-    m.$replay();
-  });
-};
-
-
-/**
- * Calls reset on each controlled mock.
- */
-goog.testing.MockControl.prototype.$resetAll = function() {
-  goog.array.forEach(this.mocks_, function(m) {
-    m.$reset();
-  });
-};
-
-
-/**
- * Calls verify on each controlled mock.
- */
-goog.testing.MockControl.prototype.$verifyAll = function() {
-  goog.array.forEach(this.mocks_, function(m) {
-    m.$verify();
-  });
-};
-
-
-/**
- * Calls tearDown on each controlled mock, if necesssary.
- */
-goog.testing.MockControl.prototype.$tearDown = function() {
-  goog.array.forEach(this.mocks_, function(m) {
-    // $tearDown if defined.
-    if (m.$tearDown) {
-      m.$tearDown();
-    }
-    // TODO(user): Somehow determine if verifyAll should have been called
-    // but was not.
-  });
-};
-
-
-/**
- * Creates a controlled StrictMock.  Passes its arguments through to the
- * StrictMock constructor.
- * @param {Object|Function} objectToMock The object that should be mocked, or
- *    the constructor of an object to mock.
- * @param {boolean=} opt_mockStaticMethods An optional argument denoting that
- *     a mock should be constructed from the static functions of a class.
- * @param {boolean=} opt_createProxy An optional argument denoting that
- *     a proxy for the target mock should be created.
- * @return {!goog.testing.StrictMock} The mock object.
- */
-goog.testing.MockControl.prototype.createStrictMock = function(
-    objectToMock, opt_mockStaticMethods, opt_createProxy) {
-  var m = new goog.testing.StrictMock(objectToMock, opt_mockStaticMethods,
-                                      opt_createProxy);
-  this.addMock(m);
-  return m;
-};
-
-
-/**
- * Creates a controlled LooseMock.  Passes its arguments through to the
- * LooseMock constructor.
- * @param {Object|Function} objectToMock The object that should be mocked, or
- *    the constructor of an object to mock.
- * @param {boolean=} opt_ignoreUnexpectedCalls Whether to ignore unexpected
- *     calls.
- * @param {boolean=} opt_mockStaticMethods An optional argument denoting that
- *     a mock should be constructed from the static functions of a class.
- * @param {boolean=} opt_createProxy An optional argument denoting that
- *     a proxy for the target mock should be created.
- * @return {!goog.testing.LooseMock} The mock object.
- */
-goog.testing.MockControl.prototype.createLooseMock = function(
-    objectToMock, opt_ignoreUnexpectedCalls,
-    opt_mockStaticMethods, opt_createProxy) {
-  var m = new goog.testing.LooseMock(objectToMock, opt_ignoreUnexpectedCalls,
-                                     opt_mockStaticMethods, opt_createProxy);
-  this.addMock(m);
-  return m;
-};
-
-
-/**
- * Creates a controlled FunctionMock.  Passes its arguments through to the
- * FunctionMock constructor.
- * @param {string=} opt_functionName The optional name of the function to mock
- *     set to '[anonymous mocked function]' if not passed in.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {goog.testing.MockInterface} The mocked function.
- */
-goog.testing.MockControl.prototype.createFunctionMock = function(
-    opt_functionName, opt_strictness) {
-  var m = goog.testing.createFunctionMock(opt_functionName, opt_strictness);
-  this.addMock(m);
-  return m;
-};
-
-
-/**
- * Creates a controlled MethodMock.  Passes its arguments through to the
- * MethodMock constructor.
- * @param {Object} scope The scope of the method to be mocked out.
- * @param {string} functionName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked method.
- */
-goog.testing.MockControl.prototype.createMethodMock = function(
-    scope, functionName, opt_strictness) {
-  var m = goog.testing.createMethodMock(scope, functionName, opt_strictness);
-  this.addMock(m);
-  return m;
-};
-
-
-/**
- * Creates a controlled MethodMock for a constructor.  Passes its arguments
- * through to the MethodMock constructor. See
- * {@link goog.testing.createConstructorMock} for details.
- * @param {Object} scope The scope of the constructor to be mocked out.
- * @param {string} constructorName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked method.
- */
-goog.testing.MockControl.prototype.createConstructorMock = function(
-    scope, constructorName, opt_strictness) {
-  var m = goog.testing.createConstructorMock(scope, constructorName,
-                                             opt_strictness);
-  this.addMock(m);
-  return m;
-};
-
-
-/**
- * Creates a controlled GlobalFunctionMock.  Passes its arguments through to the
- * GlobalFunctionMock constructor.
- * @param {string} functionName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked function.
- */
-goog.testing.MockControl.prototype.createGlobalFunctionMock = function(
-    functionName, opt_strictness) {
-  var m = goog.testing.createGlobalFunctionMock(functionName, opt_strictness);
-  this.addMock(m);
-  return m;
-};

package/lib/goog/testing/mockinterface.js

@@ -1,45 +0,0 @@
-// Copyright 2010 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @fileoverview An interface that all mocks should share.
- * @author nicksantos@google.com (Nick Santos)
- */
-
-goog.provide('goog.testing.MockInterface');
-
-
-
-/** @interface */
-goog.testing.MockInterface = function() {};
-
-
-/**
- * Write down all the expected functions that have been called on the
- * mock so far. From here on out, future function calls will be
- * compared against this list.
- */
-goog.testing.MockInterface.prototype.$replay = function() {};
-
-
-/**
- * Reset the mock.
- */
-goog.testing.MockInterface.prototype.$reset = function() {};
-
-
-/**
- * Assert that the expected function calls match the actual calls.
- */
-goog.testing.MockInterface.prototype.$verify = function() {};

package/lib/goog/testing/mockmatchers.js

@@ -1,400 +0,0 @@
-// Copyright 2008 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @fileoverview Matchers to be used with the mock utilities.  They allow for
- * flexible matching by type.  Custom matchers can be created by passing a
- * matcher function into an ArgumentMatcher instance.
- *
- * For examples, please see the unit test.
- *
- */
-
-
-goog.provide('goog.testing.mockmatchers');
-goog.provide('goog.testing.mockmatchers.ArgumentMatcher');
-goog.provide('goog.testing.mockmatchers.IgnoreArgument');
-goog.provide('goog.testing.mockmatchers.InstanceOf');
-goog.provide('goog.testing.mockmatchers.ObjectEquals');
-goog.provide('goog.testing.mockmatchers.RegexpMatch');
-goog.provide('goog.testing.mockmatchers.SaveArgument');
-goog.provide('goog.testing.mockmatchers.TypeOf');
-
-goog.require('goog.array');
-goog.require('goog.dom');
-goog.require('goog.testing.asserts');
-
-
-
-/**
- * A simple interface for executing argument matching.  A match in this case is
- * testing to see if a supplied object fits a given criteria.  True is returned
- * if the given criteria is met.
- * @param {Function=} opt_matchFn A function that evaluates a given argument
- *     and returns true if it meets a given criteria.
- * @param {?string=} opt_matchName The name expressing intent as part of
- *      an error message for when a match fails.
- * @constructor
- */
-goog.testing.mockmatchers.ArgumentMatcher =
-    function(opt_matchFn, opt_matchName) {
-  /**
-   * A function that evaluates a given argument and returns true if it meets a
-   * given criteria.
-   * @type {Function}
-   * @private
-   */
-  this.matchFn_ = opt_matchFn || null;
-
-  /**
-   * A string indicating the match intent (e.g. isBoolean or isString).
-   * @type {?string}
-   * @private
-   */
-  this.matchName_ = opt_matchName || null;
-};
-
-
-/**
- * A function that takes a match argument and an optional MockExpectation
- * which (if provided) will get error information and returns whether or
- * not it matches.
- * @param {*} toVerify The argument that should be verified.
- * @param {goog.testing.MockExpectation?=} opt_expectation The expectation
- *     for this match.
- * @return {boolean} Whether or not a given argument passes verification.
- */
-goog.testing.mockmatchers.ArgumentMatcher.prototype.matches =
-    function(toVerify, opt_expectation) {
-  if (this.matchFn_) {
-    var isamatch = this.matchFn_(toVerify);
-    if (!isamatch && opt_expectation) {
-      if (this.matchName_) {
-        opt_expectation.addErrorMessage('Expected: ' +
-            this.matchName_ + ' but was: ' + _displayStringForValue(toVerify));
-      } else {
-        opt_expectation.addErrorMessage('Expected: missing mockmatcher' +
-            ' description but was: ' +
-            _displayStringForValue(toVerify));
-      }
-    }
-    return isamatch;
-  } else {
-    throw Error('No match function defined for this mock matcher');
-  }
-};
-
-
-
-/**
- * A matcher that verifies that an argument is an instance of a given class.
- * @param {Function} ctor The class that will be used for verification.
- * @constructor
- * @extends {goog.testing.mockmatchers.ArgumentMatcher}
- * @final
- */
-goog.testing.mockmatchers.InstanceOf = function(ctor) {
-  goog.testing.mockmatchers.ArgumentMatcher.call(this,
-      function(obj) {
-        return obj instanceof ctor;
-        // NOTE: Browser differences on ctor.toString() output
-        // make using that here problematic. So for now, just let
-        // people know the instanceOf() failed without providing
-        // browser specific details...
-      }, 'instanceOf()');
-};
-goog.inherits(goog.testing.mockmatchers.InstanceOf,
-    goog.testing.mockmatchers.ArgumentMatcher);
-
-
-
-/**
- * A matcher that verifies that an argument is of a given type (e.g. "object").
- * @param {string} type The type that a given argument must have.
- * @constructor
- * @extends {goog.testing.mockmatchers.ArgumentMatcher}
- * @final
- */
-goog.testing.mockmatchers.TypeOf = function(type) {
-  goog.testing.mockmatchers.ArgumentMatcher.call(this,
-      function(obj) {
-        return goog.typeOf(obj) == type;
-      }, 'typeOf(' + type + ')');
-};
-goog.inherits(goog.testing.mockmatchers.TypeOf,
-    goog.testing.mockmatchers.ArgumentMatcher);
-
-
-
-/**
- * A matcher that verifies that an argument matches a given RegExp.
- * @param {RegExp} regexp The regular expression that the argument must match.
- * @constructor
- * @extends {goog.testing.mockmatchers.ArgumentMatcher}
- * @final
- */
-goog.testing.mockmatchers.RegexpMatch = function(regexp) {
-  goog.testing.mockmatchers.ArgumentMatcher.call(this,
-      function(str) {
-        return regexp.test(str);
-      }, 'match(' + regexp + ')');
-};
-goog.inherits(goog.testing.mockmatchers.RegexpMatch,
-    goog.testing.mockmatchers.ArgumentMatcher);
-
-
-
-/**
- * A matcher that always returns true. It is useful when the user does not care
- * for some arguments.
- * For example: mockFunction('username', 'password', IgnoreArgument);
- * @constructor
- * @extends {goog.testing.mockmatchers.ArgumentMatcher}
- * @final
- */
-goog.testing.mockmatchers.IgnoreArgument = function() {
-  goog.testing.mockmatchers.ArgumentMatcher.call(this,
-      function() {
-        return true;
-      }, 'true');
-};
-goog.inherits(goog.testing.mockmatchers.IgnoreArgument,
-    goog.testing.mockmatchers.ArgumentMatcher);
-
-
-
-/**
- * A matcher that verifies that the argument is an object that equals the given
- * expected object, using a deep comparison.
- * @param {Object} expectedObject An object to match against when
- *     verifying the argument.
- * @constructor
- * @extends {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.ObjectEquals = function(expectedObject) {
-  goog.testing.mockmatchers.ArgumentMatcher.call(this,
-      function(matchObject) {
-        assertObjectEquals('Expected equal objects', expectedObject,
-            matchObject);
-        return true;
-      }, 'objectEquals(' + expectedObject + ')');
-};
-goog.inherits(goog.testing.mockmatchers.ObjectEquals,
-    goog.testing.mockmatchers.ArgumentMatcher);
-
-
-/** @override */
-goog.testing.mockmatchers.ObjectEquals.prototype.matches =
-    function(toVerify, opt_expectation) {
-  // Override the default matches implementation to capture the exception thrown
-  // by assertObjectEquals (if any) and add that message to the expectation.
-  try {
-    return goog.testing.mockmatchers.ObjectEquals.superClass_.matches.call(
-        this, toVerify, opt_expectation);
-  } catch (e) {
-    if (opt_expectation) {
-      opt_expectation.addErrorMessage(e.message);
-    }
-    return false;
-  }
-};
-
-
-
-/**
- * A matcher that saves the argument that it is verifying so that your unit test
- * can perform extra tests with this argument later.  For example, if the
- * argument is a callback method, the unit test can then later call this
- * callback to test the asynchronous portion of the call.
- * @param {goog.testing.mockmatchers.ArgumentMatcher|Function=} opt_matcher
- *     Argument matcher or matching function that will be used to validate the
- *     argument.  By default, argument will always be valid.
- * @param {?string=} opt_matchName The name expressing intent as part of
- *      an error message for when a match fails.
- * @constructor
- * @extends {goog.testing.mockmatchers.ArgumentMatcher}
- * @final
- */
-goog.testing.mockmatchers.SaveArgument = function(opt_matcher, opt_matchName) {
-  goog.testing.mockmatchers.ArgumentMatcher.call(
-      this, /** @type {Function} */ (opt_matcher), opt_matchName);
-
-  if (opt_matcher instanceof goog.testing.mockmatchers.ArgumentMatcher) {
-    /**
-     * Delegate match requests to this matcher.
-     * @type {goog.testing.mockmatchers.ArgumentMatcher}
-     * @private
-     */
-    this.delegateMatcher_ = opt_matcher;
-  } else if (!opt_matcher) {
-    this.delegateMatcher_ = goog.testing.mockmatchers.ignoreArgument;
-  }
-};
-goog.inherits(goog.testing.mockmatchers.SaveArgument,
-    goog.testing.mockmatchers.ArgumentMatcher);
-
-
-/** @override */
-goog.testing.mockmatchers.SaveArgument.prototype.matches = function(
-    toVerify, opt_expectation) {
-  this.arg = toVerify;
-  if (this.delegateMatcher_) {
-    return this.delegateMatcher_.matches(toVerify, opt_expectation);
-  }
-  return goog.testing.mockmatchers.SaveArgument.superClass_.matches.call(
-      this, toVerify, opt_expectation);
-};
-
-
-/**
- * Saved argument that was verified.
- * @type {*}
- */
-goog.testing.mockmatchers.SaveArgument.prototype.arg;
-
-
-/**
- * An instance of the IgnoreArgument matcher. Returns true for all matches.
- * @type {goog.testing.mockmatchers.IgnoreArgument}
- */
-goog.testing.mockmatchers.ignoreArgument =
-    new goog.testing.mockmatchers.IgnoreArgument();
-
-
-/**
- * A matcher that verifies that an argument is an array.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isArray =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isArray,
-        'isArray');
-
-
-/**
- * A matcher that verifies that an argument is a array-like.  A NodeList is an
- * example of a collection that is very close to an array.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isArrayLike =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isArrayLike,
-        'isArrayLike');
-
-
-/**
- * A matcher that verifies that an argument is a date-like.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isDateLike =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isDateLike,
-        'isDateLike');
-
-
-/**
- * A matcher that verifies that an argument is a string.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isString =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isString,
-        'isString');
-
-
-/**
- * A matcher that verifies that an argument is a boolean.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isBoolean =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isBoolean,
-        'isBoolean');
-
-
-/**
- * A matcher that verifies that an argument is a number.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isNumber =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isNumber,
-        'isNumber');
-
-
-/**
- * A matcher that verifies that an argument is a function.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isFunction =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isFunction,
-        'isFunction');
-
-
-/**
- * A matcher that verifies that an argument is an object.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isObject =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.isObject,
-        'isObject');
-
-
-/**
- * A matcher that verifies that an argument is like a DOM node.
- * @type {goog.testing.mockmatchers.ArgumentMatcher}
- */
-goog.testing.mockmatchers.isNodeLike =
-    new goog.testing.mockmatchers.ArgumentMatcher(goog.dom.isNodeLike,
-        'isNodeLike');
-
-
-/**
- * A function that checks to see if an array matches a given set of
- * expectations.  The expectations array can be a mix of ArgumentMatcher
- * implementations and values.  True will be returned if values are identical or
- * if a matcher returns a positive result.
- * @param {Array<?>} expectedArr An array of expectations which can be either
- *     values to check for equality or ArgumentMatchers.
- * @param {Array<?>} arr The array to match.
- * @param {goog.testing.MockExpectation?=} opt_expectation The expectation
- *     for this match.
- * @return {boolean} Whether or not the given array matches the expectations.
- */
-goog.testing.mockmatchers.flexibleArrayMatcher =
-    function(expectedArr, arr, opt_expectation) {
-  return goog.array.equals(expectedArr, arr, function(a, b) {
-    var errCount = 0;
-    if (opt_expectation) {
-      errCount = opt_expectation.getErrorMessageCount();
-    }
-    var isamatch = a === b ||
-        a instanceof goog.testing.mockmatchers.ArgumentMatcher &&
-        a.matches(b, opt_expectation);
-    var failureMessage = null;
-    if (!isamatch) {
-      failureMessage = goog.testing.asserts.findDifferences(a, b);
-      isamatch = !failureMessage;
-    }
-    if (!isamatch && opt_expectation) {
-      // If the error count changed, the match sent out an error
-      // message. If the error count has not changed, then
-      // we need to send out an error message...
-      if (errCount == opt_expectation.getErrorMessageCount()) {
-        // Use the _displayStringForValue() from assert.js
-        // for consistency...
-        if (!failureMessage) {
-          failureMessage = 'Expected: ' + _displayStringForValue(a) +
-              ' but was: ' + _displayStringForValue(b);
-        }
-        opt_expectation.addErrorMessage(failureMessage);
-      }
-    }
-    return isamatch;
-  });
-};