Debian Codegraph @

pretender/test/calling_test.js

raw
1 var describe = QUnit.module;
2 var it = QUnit.test;
3 var clock;
4
5 describe('pretender invoking', function(config) {
6 config.beforeEach(function() {
7 this.pretender = new Pretender();
8 });
9
10 config.afterEach(function() {
11 if (clock) { clock.restore(); }
12 this.pretender.shutdown();
13 });
14
15 it('a mapping function is optional', function(assert) {
16 var wasCalled;
17
18 this.pretender.get('/some/path', function() {
19 wasCalled = true;
20 });
21
22 $.ajax({ url: '/some/path' });
23 assert.ok(wasCalled);
24 });
25
26 it('mapping can be called directly', function(assert) {
27 var wasCalled;
28 function map() {
29 this.get('/some/path', function() {
30 wasCalled = true;
31 });
32 }
33
34 this.pretender.map(map);
35
36 $.ajax({ url: '/some/path' });
37 assert.ok(wasCalled);
38 });
39
40 it('clobbering duplicate mapping works', function(assert) {
41 var wasCalled, wasCalled2;
42 function map() {
43 this.get('/some/path', function() {
44 wasCalled = true;
45 });
46 }
47 function map2() {
48 this.get('/some/path', function() {
49 wasCalled2 = true;
50 });
51 }
52
53 this.pretender.map(map);
54 this.pretender.map(map2);
55
56 $.ajax({ url: '/some/path' });
57
58 assert.ok(!wasCalled);
59 assert.ok(wasCalled2);
60 });
61
62 it('ordered duplicate mapping works', function(assert) {
63 var wasCalled, wasCalled2;
64 function map() {
65 this.get('/some/path', function() {
66 wasCalled = true;
67 });
68 }
69
70 this.pretender.map(map);
71 $.ajax({ url: '/some/path' });
72
73 function map2() {
74 this.get('/some/path', function() {
75 wasCalled2 = true;
76 });
77 }
78
79 this.pretender.map(map2);
80 $.ajax({ url: '/some/path' });
81
82 assert.ok(wasCalled);
83 assert.ok(wasCalled2);
84 });
85
86 it('params are passed', function(assert) {
87 var params;
88 this.pretender.get('/some/path/:id', function(request) {
89 params = request.params;
90 });
91
92 $.ajax({ url: '/some/path/1' });
93 assert.equal(params.id, 1);
94 });
95
96 it('queryParams are passed', function(assert) {
97 var params;
98 this.pretender.get('/some/path', function(request) {
99 params = request.queryParams;
100 });
101
102 $.ajax({ url: '/some/path?zulu=nation' });
103 assert.equal(params.zulu, 'nation');
104 });
105
106 it('request body is accessible', function(assert) {
107 var params;
108 this.pretender.post('/some/path/1', function(request) {
109 params = request.requestBody;
110 });
111
112 $.ajax({
113 method: 'post',
114 url: '/some/path/1',
115 data: {
116 ok: true,
117 },
118 });
119 assert.equal(params, 'ok=true');
120 });
121
122 it('request headers are accessible', function(assert) {
123 var headers;
124 this.pretender.post('/some/path/1', function(request) {
125 headers = request.requestHeaders;
126 });
127
128 $.ajax({
129 method: 'post',
130 url: '/some/path/1',
131 headers: {
132 'A-Header': 'value',
133 },
134 });
135 assert.equal(headers['A-Header'], 'value');
136 });
137
138 it('adds requests to the list of handled requests', function(assert) {
139 this.pretender.get('/some/path', function(/*request*/) {
140 });
141
142 $.ajax({ url: '/some/path' });
143
144 var req = this.pretender.handledRequests[0];
145 assert.equal(req.url, '/some/path');
146 });
147
148 it('increments the handler\'s request count', function(assert) {
149 var handler = function(/*req*/) {};
150
151 this.pretender.get('/some/path', handler);
152
153 $.ajax({ url: '/some/path' });
154
155 assert.equal(handler.numberOfCalls, 1);
156 });
157
158 it('handledRequest is called', function(assert) {
159 var done = assert.async();
160
161 var json = '{foo: "bar"}';
162 this.pretender.get('/some/path', function(/*req*/) {
163 return [200, {}, json];
164 });
165
166 this.pretender.handledRequest = function(verb, path, request) {
167 assert.ok(true, 'handledRequest hook was called');
168 assert.equal(verb, 'GET');
169 assert.equal(path, '/some/path');
170 assert.equal(request.responseText, json);
171 assert.equal(request.response, json);
172 assert.equal(request.status, '200');
173 done();
174 };
175
176 $.ajax({ url: '/some/path' });
177 });
178
179 it('prepareBody is called', function(assert) {
180 var done = assert.async();
181
182 var obj = { foo: 'bar' };
183 this.pretender.prepareBody = JSON.stringify;
184 this.pretender.get('/some/path', function(/*req*/) {
185 return [200, {}, obj];
186 });
187
188 $.ajax({
189 url: '/some/path',
190 success: function(resp) {
191 assert.deepEqual(JSON.parse(resp), obj);
192 done();
193 },
194 });
195 });
196
197 it('prepareHeaders is called', function(assert) {
198 var done = assert.async();
199
200 this.pretender.prepareHeaders = function(headers) {
201 headers['X-WAS-CALLED'] = 'YES';
202 return headers;
203 };
204
205 this.pretender.get('/some/path', function(/*req*/) {
206 return [200, {}, ''];
207 });
208
209 $.ajax({
210 url: '/some/path',
211 complete: function(xhr) {
212 assert.equal(xhr.getResponseHeader('X-WAS-CALLED'), 'YES');
213 done();
214 },
215 });
216 });
217
218 it('will use the latest defined handler', function(assert) {
219 assert.expect(1);
220
221 var latestHandlerWasCalled = false;
222 this.pretender.get('/some/path', function(/*request*/) {
223 assert.ok(false);
224 });
225 this.pretender.get('/some/path', function(/*request*/) {
226 latestHandlerWasCalled = true;
227 });
228 $.ajax({ url: '/some/path' });
229 assert.ok(latestHandlerWasCalled, 'calls the latest handler');
230 });
231
232 it('will error when using fully qualified URLs instead of paths', function(
233 assert
234 ) {
235 var pretender = this.pretender;
236
237 pretender.get('/some/path', function(/*request*/) {
238 return [200, {}, ''];
239 });
240
241 assert.throws(function() {
242 pretender.handleRequest({ url: 'http://myserver.com/some/path' });
243 });
244 });
245
246 it('is resolved asynchronously', function(assert) {
247 var done = assert.async();
248 var val = 'unset';
249
250 this.pretender.get('/some/path', function(/*request*/) {
251 return [200, {}, ''];
252 });
253
254 $.ajax({
255 url: '/some/path',
256 complete: function() {
257 assert.equal(val, 'set');
258 done();
259 },
260 });
261
262 assert.equal(val, 'unset');
263 val = 'set';
264 });
265
266 it('can be resolved synchronous', function(assert) {
267 var val = 0;
268
269 this.pretender.get(
270 '/some/path',
271 function(/*request*/) {
272 return [200, {}, ''];
273 },
274 false
275 );
276
277 $.ajax({
278 url: '/some/path',
279 complete: function() {
280 assert.equal(val, 0);
281 val++;
282 },
283 });
284
285 assert.equal(val, 1);
286 });
287
288 it('can be both asynchronous or synchronous based on an async function', function(
289 assert
290 ) {
291 var done = assert.async();
292
293 var isAsync = false;
294 var val = 0;
295
296 this.pretender.get(
297 '/some/path',
298 function(/*request*/) {
299 return [200, {}, ''];
300 },
301 function() {
302 return isAsync;
303 }
304 );
305
306 $.ajax({
307 url: '/some/path',
308 complete: function() {
309 assert.equal(val, 0);
310 val++;
311 },
312 });
313
314 assert.equal(val, 1);
315 val++;
316
317 isAsync = 0;
318
319 $.ajax({
320 url: '/some/path',
321 complete: function() {
322 assert.equal(val, 3);
323 done();
324 },
325 });
326
327 assert.equal(val, 2);
328 val++;
329 });
330
331 it('can be configured to resolve after a specified time', function(assert) {
332 var done = assert.async();
333
334 var val = 0;
335
336 this.pretender.get(
337 '/some/path',
338 function(/*request*/) {
339 return [200, {}, ''];
340 },
341 100
342 );
343
344 $.ajax({
345 url: '/some/path',
346 complete: function() {
347 assert.equal(val, 1);
348 done();
349 },
350 });
351
352 setTimeout(function() {
353 assert.equal(val, 0);
354 val++;
355 }, 0);
356 });
357
358 it('can be configured to require manually resolution', function(assert) {
359 var val = 0;
360 var req = $.ajaxSettings.xhr();
361
362 this.pretender.get(
363 '/some/path',
364 function(/*request*/) {
365 return [200, {}, ''];
366 },
367 true
368 );
369
370 $.ajax({
371 url: '/some/path',
372 xhr: function() {
373 // use the xhr we already made and have a reference to
374 return req;
375 },
376 complete: function() {
377 assert.equal(val, 1);
378 val++;
379 },
380 });
381
382 assert.equal(val, 0);
383 val++;
384
385 this.pretender.resolve(req);
386
387 assert.equal(val, 2);
388 });
389
390 it('requiresManualResolution returns true for endpoints configured with `true` for async', function(
391 assert
392 ) {
393 this.pretender.get('/some/path', function(/*request*/) {}, true);
394 this.pretender.get('/some/other/path', function() {});
395
396 assert.ok(this.pretender.requiresManualResolution('get', '/some/path'));
397 assert.ok(
398 !this.pretender.requiresManualResolution('get', '/some/other/path')
399 );
400 });
401
402 it(
403 'async requests with `onprogress` upload events in the upload ' +
404 ' trigger a progress event each 50ms',
405 function(assert) {
406 clock = sinon.useFakeTimers();
407 var progressEventCount = 0;
408 this.pretender.post(
409 '/uploads',
410 function(/*request*/) {
411 return [200, {}, ''];
412 },
413 300
414 );
415
416 var xhr = new window.XMLHttpRequest();
417 xhr.open('POST', '/uploads');
418 var lastLoaded = 0;
419 var postBody = 'some data';
420 xhr.upload.onprogress = function(event) {
421 var loaded = event.loaded;
422 var total = event.total;
423 assert.equal(total, postBody.length, 'ProgressEvent has total of requestBody byte size');
424 assert.ok(loaded > lastLoaded, 'making progress');
425 assert.ok(loaded <= total, 'loaded should always not exceed total');
426 progressEventCount++;
427 };
428 xhr.send(postBody);
429 clock.tick(310);
430 assert.equal(
431 progressEventCount,
432 6,
433 'In a request of 300ms the progress event has been fired 5 times'
434 );
435 }
436 );
437
438 it('`onprogress` returns correct values for loaded, total in case of FormData requestbody', function(assert) {
439 clock = sinon.useFakeTimers();
440 this.pretender.post('/uploads', function(/*request*/) {
441 return [200, {}, ''];
442 }, 210);
443
444 var progressEventCount = 0;
445 var xhr = new window.XMLHttpRequest();
446 xhr.open('POST', '/uploads');
447 var formData = new FormData();
448 formData.set('field1', 'some value');
449 formData.set('field2', 'another value');
450 formData.set('file1', new Blob(['some file']));
451 formData.set('file2', new Blob(['another file']));
452 var totalSize = 10 + 13 + 9 + 12; // sum of the above fields
453 var lastLoaded = 0;
454 xhr.upload.onprogress = function(event) {
455 var loaded = event.loaded;
456 var total = event.total;
457 assert.equal(total, totalSize, 'ProgressEvent has total of requestBody byte size');
458 assert.ok(loaded > lastLoaded, 'making progress');
459 assert.ok(loaded <= total, 'loaded should always not exceed total');
460 lastLoaded = loaded;
461 progressEventCount++;
462 };
463 xhr.send(formData);
464 clock.tick(510);
465 assert.equal(
466 progressEventCount,
467 5,
468 'No `onprogress` events are fired after the the request finalizes'
469 );
470 assert.equal(lastLoaded, totalSize, 'Final progress event should match total body size');
471 });
472
473 it('`onprogress` upload events don\'t keep firing once the request has ended', function(
474 assert
475 ) {
476 clock = sinon.useFakeTimers();
477 var progressEventCount = 0;
478 this.pretender.post(
479 '/uploads',
480 function(/*request*/) {
481 return [200, {}, ''];
482 },
483 210
484 );
485
486 var xhr = new window.XMLHttpRequest();
487 xhr.open('POST', '/uploads');
488 var lastLoaded = 0;
489 var postBody = new Blob(['some data']);
490 xhr.upload.onprogress = function(event) {
491 var loaded = event.loaded;
492 var total = event.total;
493 assert.equal(total, postBody.size, 'ProgressEvent has total of requestBody byte size');
494 assert.ok(loaded > lastLoaded, 'making progress');
495 assert.ok(loaded <= total, 'loaded should always not exceed total');
496 progressEventCount++;
497 lastLoaded = loaded;
498 };
499 xhr.send(postBody);
500 clock.tick(510);
501 assert.equal(
502 progressEventCount,
503 5,
504 'No `onprogress` events are fired after the the request finalizes'
505 );
506 assert.equal(lastLoaded, postBody.size, 'Final progress event should match total body size');
507 });
508
509 it('no progress upload events are fired after the request is aborted', function(
510 assert
511 ) {
512 var progressEventCount = 0;
513
514 clock = sinon.useFakeTimers();
515
516 this.pretender.post(
517 '/uploads',
518 function(/*request*/) {
519 return [200, {}, ''];
520 },
521 210
522 );
523
524 var xhr = new window.XMLHttpRequest();
525 xhr.open('POST', '/uploads');
526 var postBody = new ArrayBuffer(8);
527 xhr.upload.onprogress = function(event) {
528 var loaded = event.loaded;
529 var total = event.total;
530 assert.equal(total, postBody.byteLength, 'ProgressEvent has total of requestBody byte size');
531 assert.ok(loaded > 0, 'making progress');
532 assert.ok(loaded <= total, 'loaded should always not exceed total');
533 progressEventCount++;
534 };
535 xhr.send(postBody);
536
537 clock.tick(90);
538 xhr.abort();
539 clock.tick(220);
540 assert.equal(
541 progressEventCount,
542 1,
543 'only one progress event was triggered because the request was aborted'
544 );
545 });
546
547 it('async requests with `onprogress` events trigger a progress event each 50ms', function(
548 assert
549 ) {
550 clock = sinon.useFakeTimers();
551 var progressEventCount = 0;
552 this.pretender.get(
553 '/downloads',
554 function(/*request*/) {
555 return [200, {}, ''];
556 },
557 300
558 );
559
560 var xhr = new window.XMLHttpRequest();
561 xhr.open('GET', '/downloads');
562 xhr.onprogress = function(event) {
563 assert.equal(event.total, 0, 'GET request has no requestBody');
564 assert.equal(event.loaded, event.total);
565 progressEventCount++;
566 };
567 xhr.send('some data');
568 clock.tick(310);
569 assert.equal(
570 progressEventCount,
571 6,
572 'In a request of 300ms the progress event has been fired 5 times'
573 );
574 });
575
576 it('`onprogress` download events don\'t keep firing once the request has ended', function(
577 assert
578 ) {
579 clock = sinon.useFakeTimers();
580 var progressEventCount = 0;
581 this.pretender.get(
582 '/downloads',
583 function(/*request*/) {
584 return [200, {}, ''];
585 },
586 210
587 );
588
589 var xhr = new window.XMLHttpRequest();
590 xhr.open('GET', '/downloads');
591 xhr.onprogress = function(/*e*/) {
592 progressEventCount++;
593 };
594 xhr.send('some data');
595 clock.tick(510);
596 assert.equal(
597 progressEventCount,
598 5,
599 'No `onprogress` events are fired after the the request finalizes'
600 );
601 });
602
603 it('no progress download events are fired after the request is aborted', function(
604 assert
605 ) {
606 var progressEventCount = 0;
607 clock = sinon.useFakeTimers();
608 this.pretender.get(
609 '/downloads',
610 function(/*request*/) {
611 return [200, {}, ''];
612 },
613 210
614 );
615
616 var xhr = new window.XMLHttpRequest();
617 xhr.open('GET', '/downloads');
618 xhr.onprogress = function(/*e*/) {
619 progressEventCount++;
620 };
621 xhr.send('some data');
622 clock.tick(90);
623 xhr.abort();
624 clock.tick(220);
625 assert.equal(
626 progressEventCount,
627 1,
628 'only one progress event was triggered because the request was aborted'
629 );
630 });
631
632 it('resolves cross-origin requests', function(assert) {
633 var url = 'http://status.github.com/api/status';
634 var payload = 'it works!';
635 var wasCalled;
636
637 this.pretender.get(url, function() {
638 wasCalled = true;
639 return [200, {}, payload];
640 });
641
642 $.ajax({ url: url });
643 assert.ok(wasCalled);
644 });
645
646 it('accepts a handler that returns a promise', function(assert) {
647 var done = assert.async();
648
649 var json = '{foo: "bar"}';
650
651 this.pretender.get('/some/path', function(/*req*/) {
652 return new Promise(function(resolve) {
653 resolve([200, {}, json]);
654 });
655 });
656
657 this.pretender.handledRequest = function(verb, path, request) {
658 assert.ok(true, 'handledRequest hook was called');
659 assert.equal(verb, 'GET');
660 assert.equal(path, '/some/path');
661 assert.equal(request.responseText, json);
662 assert.equal(request.response, json);
663 assert.equal(request.status, '200');
664 done();
665 };
666
667 $.ajax({ url: '/some/path' });
668 });
669 });