Debian Codegraph @

closure-library/closure/goog/result/simpleresult_test.js

raw
1 // Copyright 2012 The Closure Library Authors. All Rights Reserved.
2 // Use of this source code is governed by the Apache License, Version 2.0.
3
4 goog.provide('goog.result.SimpleResultTest');
5 goog.setTestOnly('goog.result.SimpleResultTest');
6
7 goog.require('goog.Timer');
8 goog.require('goog.Promise');
9 goog.require('goog.Thenable');
10 goog.require('goog.result');
11 goog.require('goog.testing.MockClock');
12 goog.require('goog.testing.recordFunction');
13 goog.require('goog.testing.jsunit');
14
15 var result, mockClock, resultCallback;
16 var resultCallback1;
17 var resultCallback2;
18
19 function setUpPage() {
20 mockClock = new goog.testing.MockClock();
21 mockClock.install();
22 }
23
24 function setUp() {
25 mockClock.reset();
26 resultCallback = new goog.testing.recordFunction();
27 resultCallback1 = new goog.testing.recordFunction();
28 resultCallback2 = new goog.testing.recordFunction();
29 result = new goog.result.SimpleResult();
30 }
31
32 function tearDown() {
33 resultCallback = resultCallback1 = resultCallback2 = result = null;
34 }
35
36 function tearDownPage() {
37 mockClock.uninstall();
38 goog.dispose(mockClock);
39 }
40
41 function testHandlersCalledOnSuccess() {
42 result.wait(resultCallback1);
43 result.wait(resultCallback2);
44
45 assertEquals(goog.result.Result.State.PENDING, result.getState());
46 assertEquals(0, resultCallback1.getCallCount());
47 assertEquals(0, resultCallback2.getCallCount());
48
49 result.setValue(2);
50
51 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
52 assertEquals(2, result.getValue());
53 assertEquals(1, resultCallback1.getCallCount());
54 assertEquals(1, resultCallback2.getCallCount());
55
56 var res1 = resultCallback1.popLastCall().getArgument(0);
57 assertObjectEquals(result, res1);
58
59 var res2 = resultCallback2.popLastCall().getArgument(0);
60 assertObjectEquals(result, res2);
61 }
62
63 function testCustomHandlerScope() {
64 result.wait(resultCallback1);
65 var scope = {};
66 result.wait(resultCallback2, scope);
67
68 result.setValue(2);
69
70 assertEquals(1, resultCallback1.getCallCount());
71 assertEquals(1, resultCallback2.getCallCount());
72
73 var this1 = resultCallback1.popLastCall().getThis();
74 assertObjectEquals(goog.global, this1);
75
76 var this2 = resultCallback2.popLastCall().getThis();
77 assertObjectEquals(scope, this2);
78 }
79
80 function testHandlersCalledOnError() {
81 result.wait(resultCallback1);
82 result.wait(resultCallback2);
83 assertEquals(goog.result.Result.State.PENDING, result.getState());
84
85 var error = "Network Error";
86 result.setError(error);
87
88 assertEquals(goog.result.Result.State.ERROR, result.getState());
89 assertEquals(error, result.getError());
90 assertEquals(1, resultCallback1.getCallCount());
91 assertEquals(1, resultCallback2.getCallCount());
92
93 var res1 = resultCallback1.popLastCall().getArgument(0);
94 assertObjectEquals(result, res1);
95 var res2 = resultCallback2.popLastCall().getArgument(0);
96 assertObjectEquals(result, res2);
97 }
98
99 function testAttachingHandlerOnSuccessfulResult() {
100 result.setValue(2);
101 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
102 assertEquals(2, result.getValue());
103 // resultCallback should be called immediately on a resolved Result
104 assertEquals(0, resultCallback.getCallCount());
105
106 result.wait(resultCallback);
107
108 assertEquals(1, resultCallback.getCallCount());
109 var res = resultCallback.popLastCall().getArgument(0);
110 assertEquals(result, res);
111 }
112
113 function testAttachingHandlerOnErrorResult() {
114 var error = { code: -1, errorString: "Invalid JSON" };
115 result.setError(error);
116 assertEquals(goog.result.Result.State.ERROR, result.getState());
117 assertEquals(error, result.getError());
118 // resultCallback should be called immediately on a resolved Result
119 assertEquals(0, resultCallback.getCallCount());
120
121 result.wait(resultCallback);
122
123 assertEquals(1, resultCallback.getCallCount());
124 var res = resultCallback.popLastCall().getArgument(0);
125 assertEquals(result, res);
126 }
127
128 function testExceptionThrownOnMultipleSuccessfulResolutionAttempts() {
129 result.setValue(1);
130 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
131 assertEquals(1, result.getValue());
132
133 // Try to set the value again
134 var e = assertThrows(goog.bind(result.setValue, result, 3));
135 assertTrue(e instanceof goog.result.SimpleResult.StateError);
136 }
137
138 function testExceptionThrownOnMultipleErrorResolutionAttempts() {
139 assertEquals(goog.result.Result.State.PENDING, result.getState());
140
141 result.setError(5);
142
143 assertEquals(goog.result.Result.State.ERROR, result.getState());
144 assertEquals(5, result.getError());
145 // Try to set error again
146 var e = assertThrows(goog.bind(result.setError, result, 4));
147 assertTrue(e instanceof goog.result.SimpleResult.StateError);
148 }
149
150 function testExceptionThrownOnSuccessThenErrorResolutionAttempt() {
151 assertEquals(goog.result.Result.State.PENDING, result.getState());
152
153 result.setValue(1);
154
155 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
156 assertEquals(1, result.getValue());
157
158 // Try to set error after setting value
159 var e = assertThrows(goog.bind(result.setError, result, 3));
160 assertTrue(e instanceof goog.result.SimpleResult.StateError);
161 }
162
163 function testExceptionThrownOnErrorThenSuccessResolutionAttempt() {
164 assertEquals(goog.result.Result.State.PENDING, result.getState());
165
166 var error = "fail";
167 result.setError(error);
168
169 assertEquals(goog.result.Result.State.ERROR, result.getState());
170 assertEquals(error, result.getError());
171 // Try to set value after setting error
172 var e = assertThrows(goog.bind(result.setValue, result, 1));
173 assertTrue(e instanceof goog.result.SimpleResult.StateError);
174 }
175
176 function testSuccessfulAsyncResolution() {
177 result.wait(resultCallback);
178 assertEquals(goog.result.Result.State.PENDING, result.getState());
179
180 goog.Timer.callOnce(function() {
181 result.setValue(1);
182 });
183 mockClock.tick();
184
185 assertEquals(1, resultCallback.getCallCount());
186
187 var res = resultCallback.popLastCall().getArgument(0);
188 assertEquals(goog.result.Result.State.SUCCESS, res.getState());
189 assertEquals(1, res.getValue());
190 }
191
192 function testErrorAsyncResolution() {
193 result.wait(resultCallback);
194 assertEquals(goog.result.Result.State.PENDING, result.getState());
195
196 var error = 'Network failure';
197 goog.Timer.callOnce(function() {
198 result.setError(error);
199 });
200 mockClock.tick();
201
202 assertEquals(1, resultCallback.getCallCount());
203 var res = resultCallback.popLastCall().getArgument(0);
204 assertEquals(goog.result.Result.State.ERROR, res.getState());
205 assertEquals(error, res.getError());
206 }
207
208 function testCancelStateAndReturn() {
209 assertFalse(result.isCanceled());
210 var canceled = result.cancel();
211 assertTrue(result.isCanceled());
212 assertEquals(goog.result.Result.State.ERROR, result.getState());
213 assertTrue(result.getError() instanceof goog.result.Result.CancelError);
214 assertTrue(canceled);
215 }
216
217 function testErrorHandlersFireOnCancel() {
218 result.wait(resultCallback);
219 result.cancel();
220
221 assertEquals(1, resultCallback.getCallCount());
222 var lastCall = resultCallback.popLastCall();
223 var res = lastCall.getArgument(0);
224 assertEquals(goog.result.Result.State.ERROR, res.getState());
225 assertTrue(res.getError() instanceof goog.result.Result.CancelError);
226 }
227
228 function testCancelAfterSetValue() {
229 // cancel after setValue/setError => no-op
230 result.wait(resultCallback);
231 result.setValue(1);
232
233 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
234 assertEquals(1, result.getValue());
235 assertEquals(1, resultCallback.getCallCount());
236
237 result.cancel();
238
239 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
240 assertEquals(1, result.getValue());
241 assertEquals(1, resultCallback.getCallCount());
242 }
243
244 function testSetValueAfterCancel() {
245 // setValue/setError after cancel => no-op
246 result.wait(resultCallback);
247
248 result.cancel();
249 assertTrue(result.isCanceled());
250 assertTrue(result.getError() instanceof goog.result.Result.CancelError);
251
252 result.setValue(1);
253 assertTrue(result.isCanceled());
254 assertTrue(result.getError() instanceof goog.result.Result.CancelError);
255
256 result.setError(3);
257 assertTrue(result.isCanceled());
258 assertTrue(result.getError() instanceof goog.result.Result.CancelError);
259 }
260
261 function testFromResolvedPromise() {
262 var promise = goog.Promise.resolve('resolved');
263 result = goog.result.SimpleResult.fromPromise(promise);
264 assertEquals(goog.result.Result.State.PENDING, result.getState());
265 mockClock.tick();
266 assertEquals(goog.result.Result.State.SUCCESS, result.getState());
267 assertEquals('resolved', result.getValue());
268 assertEquals(undefined, result.getError());
269 }
270
271 function testFromRejectedPromise() {
272 var promise = goog.Promise.reject('rejected');
273 result = goog.result.SimpleResult.fromPromise(promise);
274 assertEquals(goog.result.Result.State.PENDING, result.getState());
275 mockClock.tick();
276 assertEquals(goog.result.Result.State.ERROR, result.getState());
277 assertEquals(undefined, result.getValue());
278 assertEquals('rejected', result.getError());
279 }
280
281 function testThen() {
282 var value1, value2;
283 result.then(function(val1) {
284 return value1 = val1;
285 }).then(function(val2) {
286 value2 = val2;
287 });
288 result.setValue('done');
289 assertUndefined(value1);
290 assertUndefined(value2);
291 mockClock.tick();
292 assertEquals('done', value1);
293 assertEquals('done', value2);
294 }
295
296 function testThen_reject() {
297 var value, reason;
298 result.then(
299 function(v) { value = v; },
300 function(r) { reason = r; });
301 result.setError(new Error('oops'));
302 assertUndefined(value);
303 mockClock.tick();
304 assertUndefined(value);
305 assertEquals('oops', reason.message);
306 }
307
308 function testPromiseAll() {
309 var promise = goog.Promise.resolve('promise');
310 goog.Promise.all([result, promise]).then(function(values) {
311 assertEquals(2, values.length);
312 assertEquals('result', values[0]);
313 assertEquals('promise', values[1]);
314 });
315 result.setValue('result');
316 mockClock.tick();
317 }
318
319 function testResolvingPromiseBlocksResult() {
320 var value;
321 goog.Promise.resolve('promise').then(function(value) {
322 result.setValue(value);
323 });
324 result.wait(function(r) {
325 value = r.getValue();
326 });
327 assertUndefined(value);
328 mockClock.tick();
329 assertEquals('promise', value);
330 }
331
332 function testRejectingPromiseBlocksResult() {
333 var err;
334 goog.Promise.reject(new Error('oops')).then(
335 undefined /* opt_onResolved */,
336 function(reason) {
337 result.setError(reason);
338 });
339 result.wait(function(r) {
340 err = r.getError();
341 });
342 assertUndefined(err);
343 mockClock.tick();
344 assertEquals('oops', err.message);
345 }
346
347 function testPromiseFromCanceledResult() {
348 var reason;
349 result.cancel();
350 result.then(
351 undefined /* opt_onResolved */,
352 function(r) {
353 reason = r;
354 });
355 mockClock.tick();
356 assertTrue(reason instanceof goog.Promise.CancellationError);
357 }
358
359 function testThenableInterface() {
360 assertTrue(goog.Thenable.isImplementedBy(result));
361 }