Debian Codegraph @

closure-library/closure/goog/testing/net/xhrio_test.js

raw
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 goog.provide('goog.testing.net.XhrIoTest');
16 goog.setTestOnly('goog.testing.net.XhrIoTest');
17
18 goog.require('goog.dom.xml');
19 goog.require('goog.events');
20 goog.require('goog.events.Event');
21 goog.require('goog.net.ErrorCode');
22 goog.require('goog.net.EventType');
23 goog.require('goog.net.XmlHttp');
24 goog.require('goog.object');
25 goog.require('goog.testing.MockControl');
26 goog.require('goog.testing.asserts');
27 goog.require('goog.testing.jsunit');
28 goog.require('goog.testing.mockmatchers.InstanceOf');
29 goog.require('goog.testing.net.XhrIo');
30
31 // In order to emulate the actual behavior of XhrIo, set this value for all
32 // tests until the default value is false.
33 goog.testing.net.XhrIo.allowUnsafeAccessToXhrIoOutsideCallbacks = false;
34
35 var mockControl;
36
37 function setUp() {
38 mockControl = new goog.testing.MockControl();
39 }
40
41 function testStaticSend() {
42 sendInstances = goog.testing.net.XhrIo.getSendInstances();
43 var returnedXhr = goog.testing.net.XhrIo.send('url');
44 assertEquals('sendInstances_ after send', 1, sendInstances.length);
45 xhr = sendInstances[sendInstances.length - 1];
46 assertTrue('isActive after request', xhr.isActive());
47 assertEquals(returnedXhr, xhr);
48 assertEquals(
49 'readyState after request', goog.net.XmlHttp.ReadyState.LOADING,
50 xhr.getReadyState());
51
52 xhr.simulateResponse(200, '');
53 assertFalse('isActive after response', xhr.isActive());
54 assertEquals(
55 'readyState after response', goog.net.XmlHttp.ReadyState.COMPLETE,
56 xhr.getReadyState());
57
58 xhr.simulateReady();
59 assertEquals('sendInstances_ after READY', 0, sendInstances.length);
60 }
61
62 function testStaticSendWithException() {
63 goog.testing.net.XhrIo.send('url', function() {
64 if (!this.isSuccess()) {
65 throw new Error('The xhr did not complete successfully!');
66 }
67 });
68 var sendInstances = goog.testing.net.XhrIo.getSendInstances();
69 var xhr = sendInstances[sendInstances.length - 1];
70 try {
71 xhr.simulateResponse(400, '');
72 } catch (e) {
73 // Do nothing with the exception; we just want to make sure
74 // the class cleans itself up properly when an exception is
75 // thrown.
76 }
77 assertEquals(
78 'Send instance array not cleaned up properly!', 0, sendInstances.length);
79 }
80
81 function testMultipleSend() {
82 var xhr = new goog.testing.net.XhrIo();
83 assertFalse('isActive before first request', xhr.isActive());
84 assertEquals(
85 'readyState before first request',
86 goog.net.XmlHttp.ReadyState.UNINITIALIZED, xhr.getReadyState());
87
88 xhr.send('url');
89 assertTrue('isActive after first request', xhr.isActive());
90 assertEquals(
91 'readyState after first request', goog.net.XmlHttp.ReadyState.LOADING,
92 xhr.getReadyState());
93
94 xhr.simulateResponse(200, '');
95 assertFalse('isActive after first response', xhr.isActive());
96 assertEquals(
97 'readyState after first response', goog.net.XmlHttp.ReadyState.COMPLETE,
98 xhr.getReadyState());
99
100 xhr.send('url');
101 assertTrue('isActive after second request', xhr.isActive());
102 assertEquals(
103 'readyState after second request', goog.net.XmlHttp.ReadyState.LOADING,
104 xhr.getReadyState());
105 }
106
107 function testGetLastUri() {
108 var xhr = new goog.testing.net.XhrIo();
109 assertEquals('nothing sent yet, empty URI', '', xhr.getLastUri());
110
111 var requestUrl = 'http://www.example.com/';
112 xhr.send(requestUrl);
113 assertEquals('message sent, URI saved', requestUrl, xhr.getLastUri());
114 }
115
116 function testGetLastMethod() {
117 var xhr = new goog.testing.net.XhrIo();
118 assertUndefined('nothing sent yet, empty method', xhr.getLastMethod());
119
120 var method = 'POKE';
121 xhr.send('http://www.example.com/', method);
122 assertEquals('message sent, method saved', method, xhr.getLastMethod());
123 xhr.simulateResponse(200, '');
124
125 xhr.send('http://www.example.com/');
126 assertEquals('message sent, method saved', 'GET', xhr.getLastMethod());
127 }
128
129 function testGetLastContent() {
130 var xhr = new goog.testing.net.XhrIo();
131 assertUndefined('nothing sent yet, empty content', xhr.getLastContent());
132
133 var postContent = 'var=value&var2=value2';
134 xhr.send('http://www.example.com/', undefined, postContent);
135 assertEquals(
136 'POST message sent, content saved', postContent, xhr.getLastContent());
137 xhr.simulateResponse(200, '');
138
139 xhr.send('http://www.example.com/');
140 assertUndefined('GET message sent, content cleaned', xhr.getLastContent());
141 }
142
143 function testGetLastRequestHeaders() {
144 var xhr = new goog.testing.net.XhrIo();
145 assertUndefined(
146 'nothing sent yet, empty headers', xhr.getLastRequestHeaders());
147
148 xhr.send(
149 'http://www.example.com/', undefined, undefined,
150 {'From': '[email protected]'});
151 assertObjectEquals(
152 'Request sent with extra headers, headers saved',
153 {'From': '[email protected]'}, xhr.getLastRequestHeaders());
154 xhr.simulateResponse(200, '');
155
156 xhr.send('http://www.example.com');
157 assertUndefined(
158 'New request sent without extra headers', xhr.getLastRequestHeaders());
159 xhr.simulateResponse(200, '');
160
161 xhr.headers.set('X', 'A');
162 xhr.headers.set('Y', 'B');
163 xhr.send(
164 'http://www.example.com/', undefined, undefined, {'Y': 'P', 'Z': 'Q'});
165 assertObjectEquals(
166 'Default headers combined with call headers',
167 {'X': 'A', 'Y': 'P', 'Z': 'Q'}, xhr.getLastRequestHeaders());
168 xhr.simulateResponse(200, '');
169 }
170
171 function testGetResponseText() {
172 // Text response came.
173 var called = false;
174 var xhr = new goog.testing.net.XhrIo();
175 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
176 called = true;
177 assertEquals('text', e.target.getResponseText());
178 });
179 xhr.simulateResponse(200, 'text');
180 assertTrue(called);
181
182 // XML response came.
183 called = false;
184 xhr = new goog.testing.net.XhrIo();
185 var xml = goog.dom.xml.createDocument();
186 xml.appendChild(xml.createElement('root'));
187 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
188 called = true;
189 var text = e.target.getResponseText();
190 assertTrue(/<root ?\/>/.test(text));
191 });
192 xhr.simulateResponse(200, xml);
193 assertTrue(called);
194
195 // Outside the callback, getResponseText returns an empty string.
196 assertEquals('', xhr.getResponseText());
197 }
198
199 function testGetResponseJson() {
200 // Valid JSON response came.
201 var called = false;
202 var xhr = new goog.testing.net.XhrIo();
203 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
204 called = true;
205 assertArrayEquals([0, 1], e.target.getResponseJson());
206 });
207 xhr.simulateResponse(200, '[0, 1]');
208 assertTrue(called);
209
210 // Valid JSON response with XSSI prefix encoded came.
211 var called = false;
212 var xhr = new goog.testing.net.XhrIo();
213 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
214 called = true;
215 assertArrayEquals([0, 1], e.target.getResponseJson(')]}\', \n'));
216 });
217 xhr.simulateResponse(200, ')]}\', \n[0, 1]');
218 assertTrue(called);
219
220 // Outside the callback, getResponseJson returns undefined.
221 assertUndefined(xhr.getResponseJson());
222
223 // Invalid JSON response came.
224 var called = false;
225 var xhr = new goog.testing.net.XhrIo();
226 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
227 called = true;
228 assertThrows(goog.bind(e.target.getResponseJson, e.target));
229 });
230 xhr.simulateResponse(200, '[0, 1');
231 assertTrue(called);
232
233 // XML response came.
234 var called = false;
235 var xhr = new goog.testing.net.XhrIo();
236 var xml = goog.dom.xml.createDocument();
237 xml.appendChild(xml.createElement('root'));
238 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
239 called = true;
240 assertThrows(goog.bind(e.target.getResponseJson, e.target));
241 });
242 xhr.simulateResponse(200, xml);
243 assertTrue(called);
244 }
245
246 function testGetResponseXml() {
247 // Text response came.
248 var called = false;
249 var xhr = new goog.testing.net.XhrIo();
250 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
251 called = true;
252 assertNull(e.target.getResponseXml());
253 });
254 xhr.simulateResponse(200, 'text');
255 assertTrue(called);
256
257 // XML response came.
258 var called = false;
259 var xhr = new goog.testing.net.XhrIo();
260 var xml = goog.dom.xml.createDocument();
261 xml.appendChild(xml.createElement('root'));
262 goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
263 called = true;
264 assertEquals(xml, e.target.getResponseXml());
265 });
266 xhr.simulateResponse(200, xml);
267 assertTrue(called);
268
269 // Outside the callback, getResponseXml returns null.
270 assertNull(xhr.getResponseXml());
271 }
272
273 function testGetResponsesAllowUnsafeAccessToXhrIoOutsideCallbacks() {
274 // Test that if true is passed for opt_allowAccessToXhrIoOutsideOfCallback,
275 // then we can call getResponse*() outside of the SUCCESS event callback.
276 goog.testing.net.XhrIo.allowUnsafeAccessToXhrIoOutsideCallbacks = true;
277
278 var xhr = new goog.testing.net.XhrIo();
279 xhr.simulateResponse(200, 'text');
280 assertEquals('text', xhr.getResponseText());
281
282 xhr.simulateResponse(200, '[0, 1]');
283 assertArrayEquals([0, 1], xhr.getResponseJson());
284
285 var xml = goog.dom.xml.createDocument();
286 xml.appendChild(xml.createElement('root'));
287 xhr.simulateResponse(200, xml);
288 assertEquals(xml, xhr.getResponseXml());
289
290 var headers = {'test1': 'foo', 'test2': 'bar'};
291 xhr.simulateResponse(200, '', headers);
292 assertObjectEquals(headers, xhr.getResponseHeaders());
293 assertEquals('test1: foo\r\ntest2: bar', xhr.getAllResponseHeaders());
294
295 // Reset the value for future tests.
296 goog.testing.net.XhrIo.allowUnsafeAccessToXhrIoOutsideCallbacks = false;
297 }
298
299 function testGetResponseHeaders_noHeadersPresent() {
300 var xhr = new goog.testing.net.XhrIo();
301 var mockListener = mockControl.createFunctionMock();
302 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
303 .$does(function(e) {
304 assertTrue(e.type == goog.net.EventType.SUCCESS);
305 assertUndefined(e.target.getResponseHeader('XHR'));
306 });
307 mockControl.$replayAll();
308 goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
309 xhr.simulateResponse(200, '');
310
311 mockControl.$verifyAll();
312 mockControl.$resetAll();
313 }
314
315 function testGetResponseHeaders_headersPresent() {
316 var xhr = new goog.testing.net.XhrIo();
317 var mockListener = mockControl.createFunctionMock();
318 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
319 .$does(function(e) {
320 assertTrue(e.type == goog.net.EventType.SUCCESS);
321 assertUndefined(e.target.getResponseHeader('XHR'));
322 assertEquals(e.target.getResponseHeader('Pragma'), 'no-cache');
323 });
324 mockControl.$replayAll();
325 goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
326 xhr.simulateResponse(200, '', {'Pragma': 'no-cache'});
327
328 mockControl.$verifyAll();
329 mockControl.$resetAll();
330 }
331
332 function testAbort_WhenNoPendingSentRequests() {
333 var xhr = new goog.testing.net.XhrIo();
334 var eventListener = mockControl.createFunctionMock();
335 mockControl.$replayAll();
336
337 goog.events.listen(xhr, goog.net.EventType.COMPLETE, eventListener);
338 goog.events.listen(xhr, goog.net.EventType.SUCCESS, eventListener);
339 goog.events.listen(xhr, goog.net.EventType.ABORT, eventListener);
340 goog.events.listen(xhr, goog.net.EventType.ERROR, eventListener);
341 goog.events.listen(xhr, goog.net.EventType.READY, eventListener);
342
343 xhr.abort();
344
345 mockControl.$verifyAll();
346 mockControl.$resetAll();
347 }
348
349 function testAbort_PendingSentRequest() {
350 var xhr = new goog.testing.net.XhrIo();
351 var mockListener = mockControl.createFunctionMock();
352
353 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
354 .$does(function(e) {
355 assertTrue(e.type == goog.net.EventType.COMPLETE);
356 assertObjectEquals(e.target, xhr);
357 assertEquals(e.target.getStatus(), -1);
358 assertEquals(e.target.getLastErrorCode(), goog.net.ErrorCode.ABORT);
359 assertTrue(e.target.isActive());
360 });
361 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
362 .$does(function(e) {
363 assertTrue(e.type == goog.net.EventType.ABORT);
364 assertObjectEquals(e.target, xhr);
365 assertTrue(e.target.isActive());
366 });
367 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
368 .$does(function(e) {
369 assertTrue(e.type == goog.net.EventType.READY);
370 assertObjectEquals(e.target, xhr);
371 assertFalse(e.target.isActive());
372 });
373 mockControl.$replayAll();
374
375 goog.events.listen(xhr, goog.net.EventType.COMPLETE, mockListener);
376 goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
377 goog.events.listen(xhr, goog.net.EventType.ABORT, mockListener);
378 goog.events.listen(xhr, goog.net.EventType.ERROR, mockListener);
379 goog.events.listen(xhr, goog.net.EventType.READY, mockListener);
380 xhr.send('dummyurl');
381 xhr.abort();
382
383 mockControl.$verifyAll();
384 mockControl.$resetAll();
385 }
386
387 function testEvents_Success() {
388 var xhr = new goog.testing.net.XhrIo();
389 var mockListener = mockControl.createFunctionMock();
390
391 var readyState = goog.net.XmlHttp.ReadyState.UNINITIALIZED;
392 function readyStateListener(e) {
393 assertEquals(e.type, goog.net.EventType.READY_STATE_CHANGE);
394 assertObjectEquals(e.target, xhr);
395 readyState++;
396 assertEquals(e.target.getReadyState(), readyState);
397 assertTrue(e.target.isActive());
398 }
399
400 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
401 .$does(function(e) {
402 assertEquals(e.type, goog.net.EventType.COMPLETE);
403 assertObjectEquals(e.target, xhr);
404 assertEquals(e.target.getLastErrorCode(), goog.net.ErrorCode.NO_ERROR);
405 assertTrue(e.target.isActive());
406 });
407 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
408 .$does(function(e) {
409 assertEquals(e.type, goog.net.EventType.SUCCESS);
410 assertObjectEquals(e.target, xhr);
411 assertTrue(e.target.isActive());
412 });
413 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
414 .$does(function(e) {
415 assertEquals(e.type, goog.net.EventType.READY);
416 assertObjectEquals(e.target, xhr);
417 assertFalse(e.target.isActive());
418 });
419 mockControl.$replayAll();
420
421 goog.events.listen(
422 xhr, goog.net.EventType.READY_STATE_CHANGE, readyStateListener);
423 goog.events.listen(xhr, goog.net.EventType.COMPLETE, mockListener);
424 goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
425 goog.events.listen(xhr, goog.net.EventType.ABORT, mockListener);
426 goog.events.listen(xhr, goog.net.EventType.ERROR, mockListener);
427 goog.events.listen(xhr, goog.net.EventType.READY, mockListener);
428 xhr.send('dummyurl');
429 xhr.simulateResponse(200, null);
430
431 mockControl.$verifyAll();
432 mockControl.$resetAll();
433 }
434
435 function testGetResponseHeaders() {
436 var xhr = new goog.testing.net.XhrIo();
437 var mockListener = mockControl.createFunctionMock();
438 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
439 .$does(function(e) {
440 var headers = e.target.getResponseHeaders();
441 assertEquals(2, goog.object.getCount(headers));
442 assertEquals('foo', headers['test1']);
443 assertEquals('bar', headers['test2']);
444 });
445 mockControl.$replayAll();
446 goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
447
448 // Simulate an XHR with 2 headers.
449 xhr.simulateResponse(200, '', {'test1': 'foo', 'test2': 'bar'});
450
451 // Outside the callback, getResponseHeaders returns an empty object.
452 assertObjectEquals({}, xhr.getResponseHeaders());
453 assertEquals('', xhr.getAllResponseHeaders());
454
455 mockControl.$verifyAll();
456 mockControl.$resetAll();
457 }
458
459 function testGetResponseHeadersWithColonInValue() {
460 var xhr = new goog.testing.net.XhrIo();
461 var mockListener = mockControl.createFunctionMock();
462 mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
463 .$does(function(e) {
464 var headers = e.target.getResponseHeaders();
465 assertEquals(1, goog.object.getCount(headers));
466 assertEquals('f:o:o', headers['test1']);
467 });
468 mockControl.$replayAll();
469 goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
470
471 // Simulate an XHR with a colon in the http header value.
472 xhr.simulateResponse(200, '', {'test1': 'f:o:o'});
473
474 mockControl.$verifyAll();
475 mockControl.$resetAll();
476 }