# lib/goog/testing/loosemock.js

1 | // Copyright 2008 The Closure Library Authors. All Rights Reserved.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS-IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | /**
16 | * @fileoverview This file defines a loose mock implementation.
17 | */
18 |
19 | goog.provide('goog.testing.LooseExpectationCollection');
20 | goog.provide('goog.testing.LooseMock');
21 |
22 | goog.require('goog.array');
23 | goog.require('goog.structs.Map');
24 | goog.require('goog.testing.Mock');
25 |
26 |
27 |
28 | /**
29 | * This class is an ordered collection of expectations for one method. Since
30 | * the loose mock does most of its verification at the time of $verify, this
31 | * class is necessary to manage the return/throw behavior when the mock is
32 | * being called.
33 | * @constructor
34 | * @final
35 | */
36 | goog.testing.LooseExpectationCollection = function() {
37 | /**
38 | * The list of expectations. All of these should have the same name.
39 | * @type {Array<goog.testing.MockExpectation>}
40 | * @private
41 | */
42 | this.expectations_ = [];
43 | };
44 |
45 |
46 | /**
47 | * Adds an expectation to this collection.
48 | * @param {goog.testing.MockExpectation} expectation The expectation to add.
49 | */
50 | goog.testing.LooseExpectationCollection.prototype.addExpectation =
51 | function(expectation) {
52 | this.expectations_.push(expectation);
53 | };
54 |
55 |
56 | /**
57 | * Gets the list of expectations in this collection.
58 | * @return {Array<goog.testing.MockExpectation>} The array of expectations.
59 | */
60 | goog.testing.LooseExpectationCollection.prototype.getExpectations = function() {
61 | return this.expectations_;
62 | };
63 |
64 |
65 |
66 | /**
67 | * This is a mock that does not care about the order of method calls. As a
68 | * result, it won't throw exceptions until verify() is called. The only
69 | * exception is that if a method is called that has no expectations, then an
70 | * exception will be thrown.
71 | * @param {Object|Function} objectToMock The object that should be mocked, or
72 | * the constructor of an object to mock.
73 | * @param {boolean=} opt_ignoreUnexpectedCalls Whether to ignore unexpected
74 | * calls.
75 | * @param {boolean=} opt_mockStaticMethods An optional argument denoting that
76 | * a mock should be constructed from the static functions of a class.
77 | * @param {boolean=} opt_createProxy An optional argument denoting that
78 | * a proxy for the target mock should be created.
79 | * @constructor
80 | * @extends {goog.testing.Mock}
81 | */
82 | goog.testing.LooseMock = function(objectToMock, opt_ignoreUnexpectedCalls,
83 | opt_mockStaticMethods, opt_createProxy) {
84 | goog.testing.Mock.call(this, objectToMock, opt_mockStaticMethods,
85 | opt_createProxy);
86 |
87 | /**
88 | * A map of method names to a LooseExpectationCollection for that method.
89 | * @type {goog.structs.Map}
90 | * @private
91 | */
92 | this.$expectations_ = new goog.structs.Map();
93 |
94 | /**
95 | * The calls that have been made; we cache them to verify at the end. Each
96 | * element is an array where the first element is the name, and the second
97 | * element is the arguments.
98 | * @type {Array<Array<*>>}
99 | * @private
100 | */
101 | this.$calls_ = [];
102 |
103 | /**
104 | * Whether to ignore unexpected calls.
105 | * @type {boolean}
106 | * @private
107 | */
108 | this.$ignoreUnexpectedCalls_ = !!opt_ignoreUnexpectedCalls;
109 | };
110 | goog.inherits(goog.testing.LooseMock, goog.testing.Mock);
111 |
112 |
113 | /**
114 | * A setter for the ignoreUnexpectedCalls field.
115 | * @param {boolean} ignoreUnexpectedCalls Whether to ignore unexpected calls.
116 | * @return {!goog.testing.LooseMock} This mock object.
117 | */
118 | goog.testing.LooseMock.prototype.$setIgnoreUnexpectedCalls = function(
119 | ignoreUnexpectedCalls) {
120 | this.$ignoreUnexpectedCalls_ = ignoreUnexpectedCalls;
121 | return this;
122 | };
123 |
124 |
125 | /** @override */
126 | goog.testing.LooseMock.prototype.$recordExpectation = function() {
127 | if (!this.$expectations_.containsKey(this.$pendingExpectation.name)) {
128 | this.$expectations_.set(this.$pendingExpectation.name,
129 | new goog.testing.LooseExpectationCollection());
130 | }
131 |
132 | var collection = this.$expectations_.get(this.$pendingExpectation.name);
133 | collection.addExpectation(this.$pendingExpectation);
134 | };
135 |
136 |
137 | /** @override */
138 | goog.testing.LooseMock.prototype.$recordCall = function(name, args) {
139 | if (!this.$expectations_.containsKey(name)) {
140 | if (this.$ignoreUnexpectedCalls_) {
141 | return;
142 | }
143 | this.$throwCallException(name, args);
144 | }
145 |
146 | // Start from the beginning of the expectations for this name,
147 | // and iterate over them until we find an expectation that matches
148 | // and also has calls remaining.
149 | var collection = this.$expectations_.get(name);
150 | var matchingExpectation = null;
151 | var expectations = collection.getExpectations();
152 | for (var i = 0; i < expectations.length; i++) {
153 | var expectation = expectations[i];
154 | if (this.$verifyCall(expectation, name, args)) {
155 | matchingExpectation = expectation;
156 | if (expectation.actualCalls < expectation.maxCalls) {
157 | break;
158 | } // else continue and see if we can find something that does match
159 | }
160 | }
161 | if (matchingExpectation == null) {
162 | this.$throwCallException(name, args, expectation);
163 | }
164 |
165 | matchingExpectation.actualCalls++;
166 | if (matchingExpectation.actualCalls > matchingExpectation.maxCalls) {
167 | this.$throwException('Too many calls to ' + matchingExpectation.name +
168 | '\nExpected: ' + matchingExpectation.maxCalls + ' but was: ' +
169 | matchingExpectation.actualCalls);
170 | }
171 |
172 | this.$calls_.push([name, args]);
173 | return this.$do(matchingExpectation, args);
174 | };
175 |
176 |
177 | /** @override */
178 | goog.testing.LooseMock.prototype.$reset = function() {
179 | goog.testing.LooseMock.superClass_.$reset.call(this);
180 |
181 | this.$expectations_ = new goog.structs.Map();
182 | this.$calls_ = [];
183 | };
184 |
185 |
186 | /** @override */
187 | goog.testing.LooseMock.prototype.$replay = function() {
188 | goog.testing.LooseMock.superClass_.$replay.call(this);
189 |
190 | // Verify that there are no expectations that can never be reached.
191 | // This can't catch every situation, but it is a decent sanity check
192 | // and it's similar to the behavior of EasyMock in java.
193 | var collections = this.$expectations_.getValues();
194 | for (var i = 0; i < collections.length; i++) {
195 | var expectations = collections[i].getExpectations();
196 | for (var j = 0; j < expectations.length; j++) {
197 | var expectation = expectations[j];
198 | // If this expectation can be called infinite times, then
199 | // check if any subsequent expectation has the exact same
200 | // argument list.
201 | if (!isFinite(expectation.maxCalls)) {
202 | for (var k = j + 1; k < expectations.length; k++) {
203 | var laterExpectation = expectations[k];
204 | if (laterExpectation.minCalls > 0 &&
205 | goog.array.equals(expectation.argumentList,
206 | laterExpectation.argumentList)) {
207 | var name = expectation.name;
208 | var argsString = this.$argumentsAsString(expectation.argumentList);
209 | this.$throwException([
210 | 'Expected call to ', name, ' with arguments ', argsString,
211 | ' has an infinite max number of calls; can\'t expect an',
212 | ' identical call later with a positive min number of calls'
213 | ].join(''));
214 | }
215 | }
216 | }
217 | }
218 | }
219 | };
220 |
221 |
222 | /** @override */
223 | goog.testing.LooseMock.prototype.$verify = function() {
224 | goog.testing.LooseMock.superClass_.$verify.call(this);
225 | var collections = this.$expectations_.getValues();
226 |
227 | for (var i = 0; i < collections.length; i++) {
228 | var expectations = collections[i].getExpectations();
229 | for (var j = 0; j < expectations.length; j++) {
230 | var expectation = expectations[j];
231 | if (expectation.actualCalls > expectation.maxCalls) {
232 | this.$throwException('Too many calls to ' + expectation.name +
233 | '\nExpected: ' + expectation.maxCalls + ' but was: ' +
234 | expectation.actualCalls);
235 | } else if (expectation.actualCalls < expectation.minCalls) {
236 | this.$throwException('Not enough calls to ' + expectation.name +
237 | '\nExpected: ' + expectation.minCalls + ' but was: ' +
238 | expectation.actualCalls);
239 | }
240 | }
241 | }
242 | };