closure 1.2.701 → 1.3.0

data/closure-library/closure/goog/testing/mockclassfactory.js

@@ -1,580 +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 This file defines a factory that can be used to mock and
- * replace an entire class.  This allows for mocks to be used effectively with
- * "new" instead of having to inject all instances.  Essentially, a given class
- * is replaced with a proxy to either a loose or strict mock.  Proxies locate
- * the appropriate mock based on constructor arguments.
- *
- * The usage is:
- * <ul>
- *   <li>Create a mock with one of the provided methods with a specifc set of
- *       constructor arguments
- *   <li>Set expectations by calling methods on the mock object
- *   <li>Call $replay() on the mock object
- *   <li>Instantiate the object as normal
- *   <li>Call $verify() to make sure that expectations were met
- *   <li>Call reset on the factory to revert all classes back to their original
- *       state
- * </ul>
- *
- * For examples, please see the unit test.
- *
- */
-
-
-goog.provide('goog.testing.MockClassFactory');
-goog.provide('goog.testing.MockClassRecord');
-
-goog.require('goog.array');
-goog.require('goog.object');
-goog.require('goog.testing.LooseMock');
-goog.require('goog.testing.StrictMock');
-goog.require('goog.testing.TestCase');
-goog.require('goog.testing.mockmatchers');
-
-
-
-/**
- * A record that represents all the data associated with a mock replacement of
- * a given class.
- * @param {Object} namespace The namespace in which the mocked class resides.
- * @param {string} className The name of the class within the namespace.
- * @param {Function} originalClass The original class implementation before it
- *     was replaced by a proxy.
- * @param {Function} proxy The proxy that replaced the original class.
- * @constructor
- */
-goog.testing.MockClassRecord = function(namespace, className, originalClass,
-    proxy) {
-  /**
-   * A standard closure namespace (e.g. goog.foo.bar) that contains the mock
-   * class referenced by this MockClassRecord.
-   * @type {Object}
-   * @private
-   */
-  this.namespace_ = namespace;
-
-  /**
-   * The name of the class within the provided namespace.
-   * @type {string}
-   * @private
-   */
-  this.className_ = className;
-
-  /**
-   * The original class implementation.
-   * @type {Function}
-   * @private
-   */
-  this.originalClass_ = originalClass;
-
-  /**
-   * The proxy being used as a replacement for the original class.
-   * @type {Function}
-   * @private
-   */
-  this.proxy_ = proxy;
-
-  /**
-   * A mocks that will be constructed by their argument list.  The entries are
-   * objects with the format {'args': args, 'mock': mock}.
-   * @type {Array.<Object>}
-   * @private
-   */
-  this.instancesByArgs_ = [];
-};
-
-
-/**
- * A mock associated with the static functions for a given class.
- * @type {goog.testing.StrictMock|goog.testing.LooseMock|null}
- * @private
- */
-goog.testing.MockClassRecord.prototype.staticMock_ = null;
-
-
-/**
- * A getter for this record's namespace.
- * @return {Object} The namespace.
- */
-goog.testing.MockClassRecord.prototype.getNamespace = function() {
-  return this.namespace_;
-};
-
-
-/**
- * A getter for this record's class name.
- * @return {string} The name of the class referenced by this record.
- */
-goog.testing.MockClassRecord.prototype.getClassName = function() {
-  return this.className_;
-};
-
-
-/**
- * A getter for the original class.
- * @return {Function} The original class implementation before mocking.
- */
-goog.testing.MockClassRecord.prototype.getOriginalClass = function() {
-  return this.originalClass_;
-};
-
-
-/**
- * A getter for the proxy being used as a replacement for the original class.
- * @return {Function} The proxy.
- */
-goog.testing.MockClassRecord.prototype.getProxy = function() {
-  return this.proxy_;
-};
-
-
-/**
- * A getter for the static mock.
- * @return {goog.testing.StrictMock|goog.testing.LooseMock|null} The static
- *     mock associated with this record.
- */
-goog.testing.MockClassRecord.prototype.getStaticMock = function() {
-  return this.staticMock_;
-};
-
-
-/**
- * A setter for the static mock.
- * @param {goog.testing.StrictMock|goog.testing.LooseMock} staticMock A mock to
- *     associate with the static functions for the referenced class.
- */
-goog.testing.MockClassRecord.prototype.setStaticMock = function(staticMock) {
-  this.staticMock_ = staticMock;
-};
-
-
-/**
- * Adds a new mock instance mapping.  The mapping connects a set of function
- * arguments to a specific mock instance.
- * @param {Array} args An array of function arguments.
- * @param {goog.testing.StrictMock|goog.testing.LooseMock} mock A mock
- *     associated with the supplied arguments.
- */
-goog.testing.MockClassRecord.prototype.addMockInstance = function(args, mock) {
-  this.instancesByArgs_.push({args: args, mock: mock});
-};
-
-
-/**
- * Finds the mock corresponding to a given argument set.  Throws an error if
- * there is no appropriate match found.
- * @param {Array} args An array of function arguments.
- * @return {goog.testing.StrictMock|goog.testing.LooseMock|null} The mock
- *     corresponding to a given argument set.
- */
-goog.testing.MockClassRecord.prototype.findMockInstance = function(args) {
-  for (var i = 0; i < this.instancesByArgs_.length; i++) {
-    var instanceArgs = this.instancesByArgs_[i].args;
-    if (goog.testing.mockmatchers.flexibleArrayMatcher(instanceArgs, args)) {
-      return this.instancesByArgs_[i].mock;
-    }
-  }
-
-  return null;
-};
-
-
-/**
- * Resets this record by reverting all the mocked classes back to the original
- * implementation and clearing out the mock instance list.
- */
-goog.testing.MockClassRecord.prototype.reset = function() {
-  this.namespace_[this.className_] = this.originalClass_;
-  this.instancesByArgs_ = [];
-};
-
-
-
-/**
- * A factory used to create new mock class instances.  It is able to generate
- * both static and loose mocks.  The MockClassFactory is a singleton since it
- * tracks the classes that have been mocked internally.
- * @constructor
- */
-goog.testing.MockClassFactory = function() {
-  if (goog.testing.MockClassFactory.instance_) {
-    return goog.testing.MockClassFactory.instance_;
-  }
-
-  /**
-   * A map from class name -> goog.testing.MockClassRecord.
-   * @type {Object}
-   * @private
-   */
-  this.mockClassRecords_ = {};
-
-  goog.testing.MockClassFactory.instance_ = this;
-};
-
-
-/**
- * A singleton instance of the MockClassFactory.
- * @type {goog.testing.MockClassFactory?}
- * @private
- */
-goog.testing.MockClassFactory.instance_ = null;
-
-
-/**
- * The names of the fields that are defined on Object.prototype.
- * @type {Array.<string>}
- * @private
- */
-goog.testing.MockClassFactory.PROTOTYPE_FIELDS_ = [
-  'constructor',
-  'hasOwnProperty',
-  'isPrototypeOf',
-  'propertyIsEnumerable',
-  'toLocaleString',
-  'toString',
-  'valueOf'
-];
-
-
-/**
- * Iterates through a namespace to find the name of a given class.  This is done
- * solely to support compilation since string identifiers would break down.
- * Tests usually aren't compiled, but the functionality is supported.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class whose name should be returned.
- * @return {string} The name of the class.
- * @private
- */
-goog.testing.MockClassFactory.prototype.getClassName_ = function(namespace,
-    classToMock) {
-  if (namespace === goog.global) {
-    namespace = goog.testing.TestCase.getGlobals();
-  }
-  for (var prop in namespace) {
-    if (namespace[prop] === classToMock) {
-      return prop;
-    }
-  }
-
-  throw Error('Class is not a part of the given namespace');
-};
-
-
-/**
- * Returns whether or not a given class has been mocked.
- * @param {string} className The name of the class.
- * @return {boolean} Whether or not the given class name has a MockClassRecord.
- * @private
- */
-goog.testing.MockClassFactory.prototype.classHasMock_ = function(className) {
-  return !!this.mockClassRecords_[className];
-};
-
-
-/**
- * Returns a proxy constructor closure.  Since this is a constructor, "this"
- * refers to the local scope of the constructed object thus bind cannot be
- * used.
- * @param {string} className The name of the class.
- * @param {Function} mockFinder A bound function that returns the mock
- *     associated with a class given the constructor's argument list.
- * @return {Function} A proxy constructor.
- * @private
- */
-goog.testing.MockClassFactory.prototype.getProxyCtor_ = function(className,
-    mockFinder) {
-  return function() {
-    this.$mock_ = mockFinder(className, arguments);
-    if (!this.$mock_) {
-      // The "arguments" variable is not a proper Array so it must be converted.
-      var args = Array.prototype.slice.call(arguments, 0);
-      throw Error('No mock found for ' + className + ' with arguments ' +
-          args.join(', '));
-    }
-  };
-};
-
-
-/**
- * Returns a proxy function for a mock class instance.  This function cannot
- * be used with bind since "this" must refer to the scope of the proxy
- * constructor.
- * @param {string} fnName The name of the function that should be proxied.
- * @return {Function} A proxy function.
- * @private
- */
-goog.testing.MockClassFactory.prototype.getProxyFunction_ = function(fnName) {
-  return function() {
-    return this.$mock_[fnName].apply(this.$mock_, arguments);
-  };
-};
-
-
-/**
- * Find a mock instance for a given class name and argument list.
- * @param {string} className The name of the class.
- * @param {Array} args The argument list to match.
- * @return {goog.testing.StrictMock|goog.testing.LooseMock} The mock found for
- *     the given argument list.
- * @private
- */
-goog.testing.MockClassFactory.prototype.findMockInstance_ = function(className,
-    args) {
-  return this.mockClassRecords_[className].findMockInstance(args);
-};
-
-
-/**
- * Create a proxy class.  A proxy will pass functions to the mock for a class.
- * The proxy class only covers prototype methods.  A static mock is not build
- * simultaneously since it might be strict or loose.  The proxy class inherits
- * from the target class in order to preserve instanceof checks.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class that will be proxied.
- * @param {string} className The name of the class.
- * @return {Function} The proxy for provided class.
- * @private
- */
-goog.testing.MockClassFactory.prototype.createProxy_ = function(namespace,
-    classToMock, className) {
-  var proxy = this.getProxyCtor_(className,
-      goog.bind(this.findMockInstance_, this));
-  var protoToProxy = classToMock.prototype;
-  goog.inherits(proxy, classToMock);
-
-  for (var prop in protoToProxy) {
-    if (goog.isFunction(protoToProxy[prop])) {
-      proxy.prototype[prop] = this.getProxyFunction_(prop);
-    }
-  }
-
-  // For IE the for-in-loop does not contain any properties that are not
-  // enumerable on the prototype object (for example isPrototypeOf from
-  // Object.prototype) and it will also not include 'replace' on objects that
-  // extend String and change 'replace' (not that it is common for anyone to
-  // extend anything except Object).
-  // TODO (arv): Implement goog.object.getIterator and replace this loop.
-
-  goog.array.forEach(goog.testing.MockClassFactory.PROTOTYPE_FIELDS_,
-      function(field) {
-        if (Object.prototype.hasOwnProperty.call(protoToProxy, field)) {
-          proxy.prototype[field] = this.getProxyFunction_(field);
-        }
-      }, this);
-
-  this.mockClassRecords_[className] = new goog.testing.MockClassRecord(
-      namespace, className, classToMock, proxy);
-  namespace[className] = proxy;
-  return proxy;
-};
-
-
-/**
- * Gets either a loose or strict mock for a given class based on a set of
- * arguments.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class that will be mocked.
- * @param {boolean} isStrict Whether or not the mock should be strict.
- * @param {Array} ctorArgs The arguments associated with this instance's
- *     constructor.
- * @return {goog.testing.StrictMock|goog.testing.LooseMock} The mock created
- *     for the provided class.
- * @private
- */
-goog.testing.MockClassFactory.prototype.getMockClass_ =
-    function(namespace, classToMock, isStrict, ctorArgs) {
-  var className = this.getClassName_(namespace, classToMock);
-
-  // The namespace and classToMock variables should be removed from the
-  // passed in argument stack.
-  ctorArgs = goog.array.slice(ctorArgs, 2);
-
-  if (goog.isFunction(classToMock)) {
-    var mock = isStrict ? new goog.testing.StrictMock(classToMock) :
-        new goog.testing.LooseMock(classToMock);
-
-    if (!this.classHasMock_(className)) {
-      this.createProxy_(namespace, classToMock, className);
-    } else {
-      var instance = this.findMockInstance_(className, ctorArgs);
-      if (instance) {
-        throw Error('Mock instance already created for ' + className +
-            ' with arguments ' + ctorArgs.join(', '));
-      }
-    }
-    this.mockClassRecords_[className].addMockInstance(ctorArgs, mock);
-
-    return mock;
-  } else {
-    throw Error('Cannot create a mock class for ' + className +
-        ' of type ' + typeof classToMock);
-  }
-};
-
-
-/**
- * Gets a strict mock for a given class.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class that will be mocked.
- * @param {...*} var_args The arguments associated with this instance's
- *     constructor.
- * @return {goog.testing.StrictMock} The mock created for the provided class.
- */
-goog.testing.MockClassFactory.prototype.getStrictMockClass =
-    function(namespace, classToMock, var_args) {
-  var args = /** @type {Array} */ (arguments);
-  return /** @type {goog.testing.StrictMock} */ (this.getMockClass_(namespace,
-      classToMock, true, args));
-};
-
-
-/**
- * Gets a loose mock for a given class.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class that will be mocked.
- * @param {...*} var_args The arguments associated with this instance's
- *     constructor.
- * @return {goog.testing.LooseMock} The mock created for the provided class.
- */
-goog.testing.MockClassFactory.prototype.getLooseMockClass =
-    function(namespace, classToMock, var_args) {
-  var args = /** @type {Array} */ (arguments);
-  return /** @type {goog.testing.LooseMock} */ (this.getMockClass_(namespace,
-      classToMock, false, args));
-};
-
-
-/**
- * Creates either a loose or strict mock for the static functions of a given
- * class.
- * @param {Function} classToMock The class whose static functions will be
- *     mocked.  This should be the original class and not the proxy.
- * @param {string} className The name of the class.
- * @param {Function} proxy The proxy that will replace the original class.
- * @param {boolean} isStrict Whether or not the mock should be strict.
- * @return {goog.testing.StrictMock|goog.testing.LooseMock} The mock created
- *     for the static functions of the provided class.
- * @private
- */
-goog.testing.MockClassFactory.prototype.createStaticMock_ =
-    function(classToMock, className, proxy, isStrict) {
-  var mock = isStrict ? new goog.testing.StrictMock(classToMock, true) :
-      new goog.testing.LooseMock(classToMock, false, true);
-
-  for (var prop in classToMock) {
-    if (goog.isFunction(classToMock[prop])) {
-      proxy[prop] = goog.bind(mock.$mockMethod, mock, prop);
-    } else if (classToMock[prop] !== classToMock.prototype) {
-      proxy[prop] = classToMock[prop];
-    }
-  }
-
-  this.mockClassRecords_[className].setStaticMock(mock);
-  return mock;
-};
-
-
-/**
- * Gets either a loose or strict mock for the static functions of a given class.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class whose static functions will be
- *     mocked.  This should be the original class and not the proxy.
- * @param {boolean} isStrict Whether or not the mock should be strict.
- * @return {goog.testing.StrictMock|goog.testing.LooseMock} The mock created
- *     for the static functions of the provided class.
- * @private
- */
-goog.testing.MockClassFactory.prototype.getStaticMock_ = function(namespace,
-    classToMock, isStrict) {
-  var className = this.getClassName_(namespace, classToMock);
-
-  if (goog.isFunction(classToMock)) {
-    if (!this.classHasMock_(className)) {
-      var proxy = this.createProxy_(namespace, classToMock, className);
-      var mock = this.createStaticMock_(classToMock, className, proxy,
-          isStrict);
-      return mock;
-    }
-
-    if (!this.mockClassRecords_[className].getStaticMock()) {
-      var proxy = this.mockClassRecords_[className].getProxy();
-      var originalClass = this.mockClassRecords_[className].getOriginalClass();
-      var mock = this.createStaticMock_(originalClass, className, proxy,
-          isStrict);
-      return mock;
-    } else {
-      var mock = this.mockClassRecords_[className].getStaticMock();
-      var mockIsStrict = mock instanceof goog.testing.StrictMock;
-
-      if (mockIsStrict != isStrict) {
-        var mockType = mock instanceof goog.testing.StrictMock ? 'strict' :
-            'loose';
-        var requestedType = isStrict ? 'strict' : 'loose';
-        throw Error('Requested a ' + requestedType + ' static mock, but a ' +
-            mockType + ' mock already exists.');
-      }
-
-      return mock;
-    }
-  } else {
-    throw Error('Cannot create a mock for the static functions of ' +
-        className + ' of type ' + typeof classToMock);
-  }
-};
-
-
-/**
- * Gets a strict mock for the static functions of a given class.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class whose static functions will be
- *     mocked.  This should be the original class and not the proxy.
- * @return {goog.testing.StrictMock} The mock created for the static functions
- *     of the provided class.
- */
-goog.testing.MockClassFactory.prototype.getStrictStaticMock =
-    function(namespace, classToMock) {
-  return /** @type {goog.testing.StrictMock} */ (this.getStaticMock_(namespace,
-      classToMock, true));
-};
-
-
-/**
- * Gets a loose mock for the static functions of a given class.
- * @param {Object} namespace A javascript namespace (e.g. goog.testing).
- * @param {Function} classToMock The class whose static functions will be
- *     mocked.  This should be the original class and not the proxy.
- * @return {goog.testing.LooseMock} The mock created for the static functions
- *     of the provided class.
- */
-goog.testing.MockClassFactory.prototype.getLooseStaticMock =
-    function(namespace, classToMock) {
-  return /** @type {goog.testing.LooseMock} */ (this.getStaticMock_(namespace,
-      classToMock, false));
-};
-
-
-/**
- * Resests the factory by reverting all mocked classes to their original
- * implementations and removing all MockClassRecords.
- */
-goog.testing.MockClassFactory.prototype.reset = function() {
-  goog.object.forEach(this.mockClassRecords_, function(record) {
-    record.reset();
-  });
-  this.mockClassRecords_ = {};
-};