/**
* @license
* Copyright The Closure Library Authors.
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview This file defines a loose mock implementation.
*/
goog.setTestOnly('goog.testing.LooseExpectationCollection');
goog.provide('goog.testing.LooseExpectationCollection');
goog.provide('goog.testing.LooseMock');
goog.require('goog.array');
goog.require('goog.asserts');
goog.require('goog.testing.Mock');
goog.requireType('goog.testing.MockExpectation');
/**
* This class is an ordered collection of expectations for one method. Since
* the loose mock does most of its verification at the time of $verify, this
* class is necessary to manage the return/throw behavior when the mock is
* being called.
* @constructor
* @final
*/
goog.testing.LooseExpectationCollection = function() {
'use strict';
/**
* The list of expectations. All of these should have the same name.
* @type {!Array<!goog.testing.MockExpectation>}
* @private
*/
this.expectations_ = [];
};
/**
* Adds an expectation to this collection.
* @param {!goog.testing.MockExpectation} expectation The expectation to add.
*/
goog.testing.LooseExpectationCollection.prototype.addExpectation = function(
expectation) {
'use strict';
this.expectations_.push(expectation);
};
/**
* Gets the list of expectations in this collection.
* @return {!Array<!goog.testing.MockExpectation>} The array of expectations.
*/
goog.testing.LooseExpectationCollection.prototype.getExpectations = function() {
'use strict';
return this.expectations_;
};
/**
* This is a mock that does not care about the order of method calls. As a
* result, it won't throw exceptions until verify() is called. The only
* exception is that if a method is called that has no expectations, then an
* exception will be thrown.
* @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.
* @constructor
* @extends {goog.testing.Mock}
*/
goog.testing.LooseMock = function(
objectToMock, opt_ignoreUnexpectedCalls, opt_mockStaticMethods,
opt_createProxy) {
'use strict';
goog.testing.Mock.call(
this, objectToMock, opt_mockStaticMethods, opt_createProxy);
/**
* A map of method names to a LooseExpectationCollection for that method.
* @type {!Map<string, !goog.testing.LooseExpectationCollection>}
* @private
*/
this.$expectations_ = new Map();
/** @private {!Set<!goog.testing.MockExpectation>} */
this.awaitingExpectations_ = new Set();
/**
* The calls that have been made; we cache them to verify at the end. Each
* element is an array where the first element is the name, and the second
* element is the arguments.
* @type {Array<Array<*>>}
* @private
*/
this.$calls_ = [];
/**
* Whether to ignore unexpected calls.
* @type {boolean}
* @private
*/
this.$ignoreUnexpectedCalls_ = !!opt_ignoreUnexpectedCalls;
};
goog.inherits(goog.testing.LooseMock, goog.testing.Mock);
/**
* A setter for the ignoreUnexpectedCalls field.
* @param {boolean} ignoreUnexpectedCalls Whether to ignore unexpected calls.
* @return {!goog.testing.LooseMock} This mock object.
*/
goog.testing.LooseMock.prototype.$setIgnoreUnexpectedCalls = function(
ignoreUnexpectedCalls) {
'use strict';
this.$ignoreUnexpectedCalls_ = ignoreUnexpectedCalls;
return this;
};
/** @override */
goog.testing.LooseMock.prototype.$recordExpectation = function() {
'use strict';
if (!this.$expectations_.has(this.$pendingExpectation.name)) {
this.$expectations_.set(
this.$pendingExpectation.name,
new goog.testing.LooseExpectationCollection());
}
var collection = this.$expectations_.get(this.$pendingExpectation.name);
collection.addExpectation(this.$pendingExpectation);
if (this.$pendingExpectation) {
this.awaitingExpectations_.add(this.$pendingExpectation);
}
};
/** @override */
goog.testing.LooseMock.prototype.$recordCall = function(name, args) {
'use strict';
if (!this.$expectations_.has(name)) {
if (this.$ignoreUnexpectedCalls_) {
return;
}
this.$throwCallException(name, args);
}
// Start from the beginning of the expectations for this name,
// and iterate over them until we find an expectation that matches
// and also has calls remaining.
var collection = this.$expectations_.get(name);
var matchingExpectation = null;
var expectations = collection.getExpectations();
for (var i = 0; i < expectations.length; i++) {
var expectation = expectations[i];
if (this.$verifyCall(expectation, name, args)) {
matchingExpectation = expectation;
if (expectation.actualCalls < expectation.maxCalls) {
break;
} // else continue and see if we can find something that does match
}
}
if (matchingExpectation == null) {
this.$throwCallException(name, args, expectation);
}
matchingExpectation.actualCalls++;
if (matchingExpectation.actualCalls > matchingExpectation.maxCalls) {
this.$throwException(
'Too many calls to ' + matchingExpectation.name + '\nExpected: ' +
matchingExpectation.maxCalls + ' but was: ' +
matchingExpectation.actualCalls);
}
if (matchingExpectation.actualCalls >= matchingExpectation.minCalls) {
this.awaitingExpectations_.delete(matchingExpectation);
this.maybeFinishedWithExpectations_();
}
this.$calls_.push([name, args]);
return this.$do(matchingExpectation, args);
};
/** @override */
goog.testing.LooseMock.prototype.$reset = function() {
'use strict';
goog.testing.LooseMock.superClass_.$reset.call(this);
this.$expectations_ = new Map();
this.awaitingExpectations_ = new Set();
this.$calls_ = [];
};
/** @override */
goog.testing.LooseMock.prototype.$replay = function() {
'use strict';
goog.testing.LooseMock.superClass_.$replay.call(this);
// Verify that there are no expectations that can never be reached.
// This can't catch every situation, but it is a decent sanity check
// and it's similar to the behavior of EasyMock in java.
for (const expectationCollection of this.$expectations_.values()) {
var expectations = expectationCollection.getExpectations();
for (var j = 0; j < expectations.length; j++) {
var expectation = expectations[j];
// If this expectation can be called infinite times, then
// check if any subsequent expectation has the exact same
// argument list.
if (!isFinite(expectation.maxCalls)) {
for (var k = j + 1; k < expectations.length; k++) {
var laterExpectation = expectations[k];
if (laterExpectation.minCalls > 0 &&
goog.array.equals(
expectation.argumentList, laterExpectation.argumentList)) {
var name = expectation.name;
var argsString = this.$argumentsAsString(expectation.argumentList);
this.$throwException([
'Expected call to ', name, ' with arguments ', argsString,
' has an infinite max number of calls; can\'t expect an',
' identical call later with a positive min number of calls'
].join(''));
}
}
}
}
}
};
/** @override */
goog.testing.LooseMock.prototype.$waitAndVerify = function() {
'use strict';
for (const expectationCollection of this.$expectations_.values()) {
var expectations = expectationCollection.getExpectations();
for (var j = 0; j < expectations.length; j++) {
var expectation = expectations[j];
goog.asserts.assert(
!isFinite(expectation.maxCalls) ||
expectation.minCalls == expectation.maxCalls,
'Mock expectations cannot have a loose number of expected calls to ' +
'use $waitAndVerify.');
}
}
var promise = goog.testing.LooseMock.base(this, '$waitAndVerify');
this.maybeFinishedWithExpectations_();
return promise;
};
/**
* @private
*/
goog.testing.LooseMock.prototype.maybeFinishedWithExpectations_ = function() {
'use strict';
var unresolvedExpectations = goog.array.some(
Array.from(this.$expectations_.values()),
function(expectationCollection) {
'use strict';
return goog.array.some(
expectationCollection.getExpectations(), function(expectation) {
'use strict';
return expectation.actualCalls < expectation.minCalls;
});
});
if (this.waitingForExpectations && !unresolvedExpectations) {
this.waitingForExpectations.resolve();
}
};
/** @override */
goog.testing.LooseMock.prototype.$verify = function() {
'use strict';
goog.testing.LooseMock.superClass_.$verify.call(this);
for (const expectationCollection of this.$expectations_.values()) {
var expectations = expectationCollection.getExpectations();
for (var j = 0; j < expectations.length; j++) {
var expectation = expectations[j];
if (expectation.actualCalls > expectation.maxCalls) {
this.$throwException(
'Too many calls to ' + expectation.name + '\nExpected: ' +
expectation.maxCalls + ' but was: ' + expectation.actualCalls);
} else if (expectation.actualCalls < expectation.minCalls) {
this.$throwException(
'Not enough calls to ' + expectation.name + '\nExpected: ' +
expectation.minCalls + ' but was: ' + expectation.actualCalls);
}
}
}
};
Codebase Browser
chromium