Update wmts-hidpi, add nicer-api-docs
This commit is contained in:
Andreas Hocevar
@@ -0,0 +1,578 @@
|
||||
// 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 {goog.array.ArrayLike} 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) {
|
||||
return /** @type {goog.testing.StrictMock} */ (this.getMockClass_(namespace,
|
||||
classToMock, true, arguments));
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
return /** @type {goog.testing.LooseMock} */ (this.getMockClass_(namespace,
|
||||
classToMock, false, arguments));
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* 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_ = {};
|
||||
};
|
||||
Reference in New Issue
Block a user