Debian Codegraph @

closure-library/closure/goog/net/streams/xhrnodereadablestream_test.js

raw
1 // Copyright 2015 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.net.streams.XhrNodeReadableStreamTest');
16 goog.setTestOnly('goog.net.streams.XhrNodeReadableStreamTest');
17
18 goog.require('goog.net.streams.NodeReadableStream');
19 goog.require('goog.net.streams.XhrNodeReadableStream');
20 goog.require('goog.net.streams.XhrStreamReader');
21 goog.require('goog.testing.PropertyReplacer');
22 goog.require('goog.testing.asserts');
23 goog.require('goog.testing.jsunit');
24
25
26 var xhrReader;
27 var xhrStream;
28
29 var EventType = goog.net.streams.NodeReadableStream.EventType;
30 var Status = goog.net.streams.XhrStreamReader.Status;
31
32 var propertyReplacer;
33
34
35
36 /**
37 * Constructs a duck-type XhrStreamReader to simulate xhr events.
38 * @constructor
39 * @struct
40 * @final
41 */
42 function MockXhrStreamReader() {
43 // mocked API
44
45 this.setStatusHandler = function(handler) { this.statusHandler_ = handler; };
46
47 this.setDataHandler = function(handler) { this.dataHandler_ = handler; };
48
49 this.getStatus = function() { return this.status_; };
50
51 // simulated events
52
53 this.onData = function(messages) { this.dataHandler_(messages); };
54
55 this.onStatus = function(status) {
56 this.status_ = status;
57 this.statusHandler_();
58 };
59 }
60
61
62 function setUp() {
63 xhrReader = new MockXhrStreamReader();
64 xhrStream = new goog.net.streams.XhrNodeReadableStream(xhrReader);
65
66 propertyReplacer = new goog.testing.PropertyReplacer();
67 propertyReplacer.replace(xhrStream, 'handleError_', function(message) {
68 // the real XhrNodeReadableStream class ignores any error thrown
69 // from inside a callback function, but we want to see those assert
70 // errors thrown by the test callback function installed by unit tests
71 fail(message);
72 });
73 }
74
75
76 function tearDown() {
77 propertyReplacer.reset();
78 }
79
80
81 function testOneDataCallback() {
82 var delivered = false;
83
84 var callback = function(message) {
85 delivered = true;
86 assertEquals('a', message.a);
87 };
88
89 xhrStream.on(EventType.DATA, callback);
90
91 xhrReader.onData([{a: 'a'}]);
92 assertTrue(delivered);
93 }
94
95
96 function testMultipleDataCallbacks() {
97 var delivered = 0;
98
99 var callback = function(message) {
100 delivered++;
101 assertEquals('a', message.a);
102 };
103
104 xhrStream.on(EventType.DATA, callback);
105 xhrStream.on(EventType.DATA, callback);
106
107 xhrReader.onData([{a: 'a'}]);
108 assertEquals(2, delivered);
109 }
110
111
112 function testOrderedDataCallbacks() {
113 var delivered = 0;
114
115 var callback1 = function(message) {
116 assertEquals(0, delivered++);
117 assertEquals('a', message.a);
118 };
119
120 var callback2 = function(message) {
121 assertEquals(1, delivered++);
122 assertEquals('a', message.a);
123 };
124
125 xhrStream.on(EventType.DATA, callback1);
126 xhrStream.on(EventType.DATA, callback2);
127
128 xhrReader.onData([{a: 'a'}]);
129 assertEquals(2, delivered);
130 }
131
132
133 function testMultipleMessagesCallbacks() {
134 var delivered = 0;
135
136 var callback1 = function(message) {
137 if (message.a) {
138 assertEquals(0, delivered++);
139 assertEquals('a', message.a);
140 } else if (message.b) {
141 assertEquals(2, delivered++);
142 assertEquals('b', message.b);
143 } else {
144 fail('unexpected message');
145 }
146 };
147
148 var callback2 = function(message) {
149 if (message.a) {
150 assertEquals(1, delivered++);
151 assertEquals('a', message.a);
152 } else if (message.b) {
153 assertEquals(3, delivered++);
154 assertEquals('b', message.b);
155 } else {
156 fail('unexpected message');
157 }
158 };
159
160 xhrStream.on(EventType.DATA, callback1);
161 xhrStream.on(EventType.DATA, callback2);
162
163 xhrReader.onData([{a: 'a'}, {b: 'b'}]);
164 assertEquals(4, delivered);
165 }
166
167
168 function testMultipleMessagesWithOnceCallbacks() {
169 var delivered = 0;
170
171 var callback1 = function(message) {
172 if (message.a) {
173 assertEquals(0, delivered++);
174 assertEquals('a', message.a);
175 } else if (message.b) {
176 assertEquals(1, delivered++);
177 assertEquals('b', message.b);
178 } else if (message.c) {
179 assertEquals(4, delivered++);
180 assertEquals('c', message.c);
181 } else {
182 fail('unexpected message');
183 }
184 };
185
186 var callback2 = function(message) {
187 if (message.a) {
188 assertEquals(2, delivered++);
189 assertEquals('a', message.a);
190 } else if (message.b) {
191 assertEquals(3, delivered++);
192 assertEquals('b', message.b);
193 } else {
194 fail('unexpected message');
195 }
196 };
197
198 xhrStream.on(EventType.DATA, callback1);
199 xhrStream.once(EventType.DATA, callback2);
200
201 xhrReader.onData([{a: 'a'}, {b: 'b'}]);
202 assertEquals(4, delivered);
203
204 xhrReader.onData([{c: 'c'}]);
205 assertEquals(5, delivered);
206 }
207
208
209 function testMultipleMessagesWithRemovedCallbacks() {
210 var delivered = 0;
211
212 var callback1 = function(message) {
213 if (message.a) {
214 assertEquals(0, delivered++);
215 assertEquals('a', message.a);
216 } else if (message.c) {
217 assertEquals(3, delivered++);
218 assertEquals('c', message.c);
219 } else {
220 fail('unexpected message');
221 }
222 };
223
224 var callback2 = function(message) {
225 if (message.a) {
226 assertEquals(1, delivered++);
227 assertEquals('a', message.a);
228 } else if (message.b) {
229 assertEquals(2, delivered++);
230 assertEquals('b', message.b);
231 } else {
232 fail('unexpected message');
233 }
234 };
235
236 xhrStream.on(EventType.DATA, callback1);
237 xhrStream.once(EventType.DATA, callback2);
238
239 xhrReader.onData([{a: 'a'}]);
240 assertEquals(2, delivered);
241
242 xhrStream.removeListener(EventType.DATA, callback1);
243 xhrStream.once(EventType.DATA, callback2);
244
245 xhrReader.onData([{b: 'b'}]);
246 assertEquals(3, delivered);
247
248 xhrStream.on(EventType.DATA, callback1);
249 xhrStream.once(EventType.DATA, callback2);
250 xhrStream.removeListener(EventType.DATA, callback2);
251
252 xhrReader.onData([{c: 'c'}]);
253 assertEquals(4, delivered);
254
255 xhrStream.removeListener(EventType.DATA, callback1);
256 xhrReader.onData([{d: 'd'}]);
257 assertEquals(4, delivered);
258 }
259
260
261 function testOrderedStatusCallbacks() {
262 checkStatusMapping(Status.ACTIVE, EventType.READABLE);
263
264 checkStatusMapping(Status.BAD_DATA, EventType.ERROR);
265 checkStatusMapping(Status.HANDLER_EXCEPTION, EventType.ERROR);
266 checkStatusMapping(Status.NO_DATA, EventType.ERROR);
267 checkStatusMapping(Status.TIMEOUT, EventType.ERROR);
268 checkStatusMapping(Status.XHR_ERROR, EventType.ERROR);
269
270 checkStatusMapping(Status.CANCELLED, EventType.CLOSE);
271
272 checkStatusMapping(Status.SUCCESS, EventType.END);
273
274 function checkStatusMapping(status, event) {
275 var delivered = 0;
276
277 var callback1 = function() {
278 if (delivered == 0) {
279 delivered++;
280 } else if (delivered == 2) {
281 delivered++;
282 } else {
283 fail('unexpected status change');
284 }
285 assertEquals(status, xhrReader.getStatus());
286 };
287
288 var callback2 = function() {
289 assertEquals(1, delivered++);
290 assertEquals(status, xhrReader.getStatus());
291 };
292
293 xhrStream.on(event, callback1);
294 xhrStream.once(event, callback2);
295
296 xhrReader.onStatus(status);
297 assertEquals(2, delivered);
298
299 xhrReader.onStatus(status);
300 assertEquals(3, delivered);
301
302 xhrStream.removeListener(event, callback1);
303
304 xhrReader.onStatus(status);
305 assertEquals(3, delivered);
306 }
307 }
308
309
310 function testOrderedStatusMultipleCallbacks() {
311 checkStatusMapping(Status.ACTIVE, EventType.READABLE);
312
313 function checkStatusMapping(status, event) {
314 var delivered = 0;
315
316 var callback1 = function() {
317 if (delivered == 0) {
318 delivered++;
319 } else if (delivered == 2) {
320 delivered++;
321 } else if (delivered == 4) {
322 delivered++;
323 } else {
324 fail('unexpected status change');
325 }
326 assertEquals(status, xhrReader.getStatus());
327 };
328
329 var callback2 = function() {
330 if (delivered == 1) {
331 delivered++;
332 } else if (delivered == 3) {
333 delivered++;
334 } else if (delivered == 5) {
335 delivered++;
336 } else if (delivered == 6) {
337 delivered++;
338 } else {
339 fail('unexpected status change');
340 }
341 assertEquals(status, xhrReader.getStatus());
342 };
343
344 xhrStream.on(event, callback1);
345 xhrStream.on(event, callback2);
346
347 xhrStream.once(event, callback1);
348 xhrStream.once(event, callback2);
349
350 xhrReader.onStatus(status);
351 assertEquals(4, delivered);
352
353 xhrReader.onStatus(status);
354 assertEquals(6, delivered);
355
356 xhrStream.removeListener(event, callback1);
357
358 xhrReader.onStatus(status);
359 assertEquals(7, delivered);
360 }
361 }