Subversion Repositories SmartDukaan

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
21627 kshitij.so 1 
/*
2 
 * jQuery File Upload Plugin Test 7.3
3 
 * https://github.com/blueimp/jQuery-File-Upload
4 
 *
5 
 * Copyright 2010, Sebastian Tschan
6 
 * https://blueimp.net
7 
 *
8 
 * Licensed under the MIT license:
9 
 * http://www.opensource.org/licenses/MIT
10 
 */
11 
 
12 
/*jslint nomen: true, unparam: true */
13 
/*global $, QUnit, window, document, expect, module, test, asyncTest, start, ok, strictEqual, notStrictEqual */
14 
 
15 
$(function () {
16 
    'use strict';
17 
 
18 
    QUnit.done = function () {
19 
        // Delete all uploaded files:
20 
        var url = $('#fileupload').prop('action');
21 
        $.getJSON(url, function (result) {
22 
            $.each(result.files, function (index, file) {
23 
                $.ajax({
24 
                    url: url + '?file=' + encodeURIComponent(file.name),
25 
                    type: 'DELETE'
26 
                });
27 
            });
28 
        });
29 
    };
30 
 
31 
    var lifecycle = {
32 
            setup: function () {
33 
                // Set the .fileupload method to the basic widget method:
34 
                $.widget('blueimp.fileupload', window.testBasicWidget, {});
35 
            },
36 
            teardown: function () {
37 
                // Remove all remaining event listeners:
38 
                $(document).unbind();
39 
            }
40 
        },
41 
        lifecycleUI = {
42 
            setup: function () {
43 
                // Set the .fileupload method to the UI widget method:
44 
                $.widget('blueimp.fileupload', window.testUIWidget, {});
45 
            },
46 
            teardown: function () {
47 
                // Remove all remaining event listeners:
48 
                $(document).unbind();
49 
            }
50 
        };
51 
 
52 
    module('Initialization', lifecycle);
53 
 
54 
    test('Widget initialization', function () {
55 
        var fu = $('#fileupload').fileupload();
56 
        ok(fu.data('blueimp-fileupload') || fu.data('fileupload'));
57 
    });
58 
 
59 
    test('Data attribute options', function () {
60 
        $('#fileupload').attr('data-url', 'http://example.org');
61 
        $('#fileupload').fileupload();
62 
        strictEqual(
63 
            $('#fileupload').fileupload('option', 'url'),
64 
            'http://example.org'
65 
        );
66 
    });
67 
 
68 
    test('File input initialization', function () {
69 
        var fu = $('#fileupload').fileupload();
70 
        ok(
71 
            fu.fileupload('option', 'fileInput').length,
72 
            'File input field inside of the widget'
73 
        );
74 
        ok(
75 
            fu.fileupload('option', 'fileInput').length,
76 
            'Widget element as file input field'
77 
        );
78 
    });
79 
 
80 
    test('Drop zone initialization', function () {
81 
        ok($('#fileupload').fileupload()
82 
            .fileupload('option', 'dropZone').length);
83 
    });
84 
 
85 
    test('Paste zone initialization', function () {
86 
        ok($('#fileupload').fileupload()
87 
            .fileupload('option', 'pasteZone').length);
88 
    });
89 
 
90 
    test('Event listeners initialization', function () {
91 
        expect(
92 
            $.support.xhrFormDataFileUpload ? 4 : 1
93 
        );
94 
        var eo = {originalEvent: {}},
95 
            fu = $('#fileupload').fileupload({
96 
                dragover: function () {
97 
                    ok(true, 'Triggers dragover callback');
98 
                    return false;
99 
                },
100 
                drop: function () {
101 
                    ok(true, 'Triggers drop callback');
102 
                    return false;
103 
                },
104 
                paste: function () {
105 
                    ok(true, 'Triggers paste callback');
106 
                    return false;
107 
                },
108 
                change: function () {
109 
                    ok(true, 'Triggers change callback');
110 
                    return false;
111 
                }
112 
            }),
113 
            fileInput = fu.fileupload('option', 'fileInput'),
114 
            dropZone = fu.fileupload('option', 'dropZone'),
115 
            pasteZone = fu.fileupload('option', 'pasteZone');
116 
        fileInput.trigger($.Event('change', eo));
117 
        dropZone.trigger($.Event('dragover', eo));
118 
        dropZone.trigger($.Event('drop', eo));
119 
        pasteZone.trigger($.Event('paste', eo));
120 
    });
121 
 
122 
    module('API', lifecycle);
123 
 
124 
    test('destroy', function () {
125 
        expect(4);
126 
        var eo = {originalEvent: {}},
127 
            options = {
128 
                dragover: function () {
129 
                    ok(true, 'Triggers dragover callback');
130 
                    return false;
131 
                },
132 
                drop: function () {
133 
                    ok(true, 'Triggers drop callback');
134 
                    return false;
135 
                },
136 
                paste: function () {
137 
                    ok(true, 'Triggers paste callback');
138 
                    return false;
139 
                },
140 
                change: function () {
141 
                    ok(true, 'Triggers change callback');
142 
                    return false;
143 
                }
144 
            },
145 
            fu = $('#fileupload').fileupload(options),
146 
            fileInput = fu.fileupload('option', 'fileInput'),
147 
            dropZone = fu.fileupload('option', 'dropZone'),
148 
            pasteZone = fu.fileupload('option', 'pasteZone');
149 
        dropZone.bind('dragover', options.dragover);
150 
        dropZone.bind('drop', options.drop);
151 
        pasteZone.bind('paste', options.paste);
152 
        fileInput.bind('change', options.change);
153 
        fu.fileupload('destroy');
154 
        fileInput.trigger($.Event('change', eo));
155 
        dropZone.trigger($.Event('dragover', eo));
156 
        dropZone.trigger($.Event('drop', eo));
157 
        pasteZone.trigger($.Event('paste', eo));
158 
    });
159 
 
160 
    test('disable/enable', function () {
161 
        expect(
162 
            $.support.xhrFormDataFileUpload ? 4 : 1
163 
        );
164 
        var eo = {originalEvent: {}},
165 
            fu = $('#fileupload').fileupload({
166 
                dragover: function () {
167 
                    ok(true, 'Triggers dragover callback');
168 
                    return false;
169 
                },
170 
                drop: function () {
171 
                    ok(true, 'Triggers drop callback');
172 
                    return false;
173 
                },
174 
                paste: function () {
175 
                    ok(true, 'Triggers paste callback');
176 
                    return false;
177 
                },
178 
                change: function () {
179 
                    ok(true, 'Triggers change callback');
180 
                    return false;
181 
                }
182 
            }),
183 
            fileInput = fu.fileupload('option', 'fileInput'),
184 
            dropZone = fu.fileupload('option', 'dropZone'),
185 
            pasteZone = fu.fileupload('option', 'pasteZone');
186 
        fu.fileupload('disable');
187 
        fileInput.trigger($.Event('change', eo));
188 
        dropZone.trigger($.Event('dragover', eo));
189 
        dropZone.trigger($.Event('drop', eo));
190 
        pasteZone.trigger($.Event('paste', eo));
191 
        fu.fileupload('enable');
192 
        fileInput.trigger($.Event('change', eo));
193 
        dropZone.trigger($.Event('dragover', eo));
194 
        dropZone.trigger($.Event('drop', eo));
195 
        pasteZone.trigger($.Event('paste', eo));
196 
    });
197 
 
198 
    test('option', function () {
199 
        expect(
200 
            $.support.xhrFormDataFileUpload ? 10 : 7
201 
        );
202 
        var eo = {originalEvent: {}},
203 
            fu = $('#fileupload').fileupload({
204 
                dragover: function () {
205 
                    ok(true, 'Triggers dragover callback');
206 
                    return false;
207 
                },
208 
                drop: function () {
209 
                    ok(true, 'Triggers drop callback');
210 
                    return false;
211 
                },
212 
                paste: function () {
213 
                    ok(true, 'Triggers paste callback');
214 
                    return false;
215 
                },
216 
                change: function () {
217 
                    ok(true, 'Triggers change callback');
218 
                    return false;
219 
                }
220 
            }),
221 
            fileInput = fu.fileupload('option', 'fileInput'),
222 
            dropZone = fu.fileupload('option', 'dropZone'),
223 
            pasteZone = fu.fileupload('option', 'pasteZone');
224 
        fu.fileupload('option', 'fileInput', null);
225 
        fu.fileupload('option', 'dropZone', null);
226 
        fu.fileupload('option', 'pasteZone', null);
227 
        fileInput.trigger($.Event('change', eo));
228 
        dropZone.trigger($.Event('dragover', eo));
229 
        dropZone.trigger($.Event('drop', eo));
230 
        pasteZone.trigger($.Event('paste', eo));
231 
        fu.fileupload('option', 'dropZone', 'body');
232 
        strictEqual(
233 
            fu.fileupload('option', 'dropZone')[0],
234 
            document.body,
235 
            'Allow a query string as parameter for the dropZone option'
236 
        );
237 
        fu.fileupload('option', 'dropZone', document);
238 
        strictEqual(
239 
            fu.fileupload('option', 'dropZone')[0],
240 
            document,
241 
            'Allow a document element as parameter for the dropZone option'
242 
        );
243 
        fu.fileupload('option', 'pasteZone', 'body');
244 
        strictEqual(
245 
            fu.fileupload('option', 'pasteZone')[0],
246 
            document.body,
247 
            'Allow a query string as parameter for the pasteZone option'
248 
        );
249 
        fu.fileupload('option', 'pasteZone', document);
250 
        strictEqual(
251 
            fu.fileupload('option', 'pasteZone')[0],
252 
            document,
253 
            'Allow a document element as parameter for the pasteZone option'
254 
        );
255 
        fu.fileupload('option', 'fileInput', ':file');
256 
        strictEqual(
257 
            fu.fileupload('option', 'fileInput')[0],
258 
            $(':file')[0],
259 
            'Allow a query string as parameter for the fileInput option'
260 
        );
261 
        fu.fileupload('option', 'fileInput', $(':file')[0]);
262 
        strictEqual(
263 
            fu.fileupload('option', 'fileInput')[0],
264 
            $(':file')[0],
265 
            'Allow a document element as parameter for the fileInput option'
266 
        );
267 
        fu.fileupload('option', 'fileInput', fileInput);
268 
        fu.fileupload('option', 'dropZone', dropZone);
269 
        fu.fileupload('option', 'pasteZone', pasteZone);
270 
        fileInput.trigger($.Event('change', eo));
271 
        dropZone.trigger($.Event('dragover', eo));
272 
        dropZone.trigger($.Event('drop', eo));
273 
        pasteZone.trigger($.Event('paste', eo));
274 
    });
275 
 
276 
    asyncTest('add', function () {
277 
        expect(2);
278 
        var param = {files: [{name: 'test'}]};
279 
        $('#fileupload').fileupload({
280 
            add: function (e, data) {
281 
                strictEqual(
282 
                    data.files[0].name,
283 
                    param.files[0].name,
284 
                    'Triggers add callback'
285 
                );
286 
            }
287 
        }).fileupload('add', param).fileupload(
288 
            'option',
289 
            'add',
290 
            function (e, data) {
291 
                data.submit().complete(function () {
292 
                    ok(true, 'data.submit() Returns a jqXHR object');
293 
                    start();
294 
                });
295 
            }
296 
        ).fileupload('add', param);
297 
    });
298 
 
299 
    asyncTest('send', function () {
300 
        expect(3);
301 
        var param = {files: [{name: 'test'}]};
302 
        $('#fileupload').fileupload({
303 
            send: function (e, data) {
304 
                strictEqual(
305 
                    data.files[0].name,
306 
                    'test',
307 
                    'Triggers send callback'
308 
                );
309 
            }
310 
        }).fileupload('send', param).fail(function () {
311 
            ok(true, 'Allows to abort the request');
312 
        }).complete(function () {
313 
            ok(true, 'Returns a jqXHR object');
314 
            start();
315 
        }).abort();
316 
    });
317 
 
318 
    module('Callbacks', lifecycle);
319 
 
320 
    asyncTest('add', function () {
321 
        expect(1);
322 
        var param = {files: [{name: 'test'}]};
323 
        $('#fileupload').fileupload({
324 
            add: function (e, data) {
325 
                ok(true, 'Triggers add callback');
326 
                start();
327 
            }
328 
        }).fileupload('add', param);
329 
    });
330 
 
331 
    asyncTest('submit', function () {
332 
        expect(1);
333 
        var param = {files: [{name: 'test'}]};
334 
        $('#fileupload').fileupload({
335 
            submit: function (e, data) {
336 
                ok(true, 'Triggers submit callback');
337 
                start();
338 
                return false;
339 
            }
340 
        }).fileupload('add', param);
341 
    });
342 
 
343 
    asyncTest('send', function () {
344 
        expect(1);
345 
        var param = {files: [{name: 'test'}]};
346 
        $('#fileupload').fileupload({
347 
            send: function (e, data) {
348 
                ok(true, 'Triggers send callback');
349 
                start();
350 
                return false;
351 
            }
352 
        }).fileupload('send', param);
353 
    });
354 
 
355 
    asyncTest('done', function () {
356 
        expect(1);
357 
        var param = {files: [{name: 'test'}]};
358 
        $('#fileupload').fileupload({
359 
            done: function (e, data) {
360 
                ok(true, 'Triggers done callback');
361 
                start();
362 
            }
363 
        }).fileupload('send', param);
364 
    });
365 
 
366 
    asyncTest('fail', function () {
367 
        expect(1);
368 
        var param = {files: [{name: 'test'}]},
369 
            fu = $('#fileupload').fileupload({
370 
                url: '404',
371 
                fail: function (e, data) {
372 
                    ok(true, 'Triggers fail callback');
373 
                    start();
374 
                }
375 
            });
376 
        (fu.data('blueimp-fileupload') || fu.data('fileupload'))
377 
            ._isXHRUpload = function () {
378 
                return true;
379 
            };
380 
        fu.fileupload('send', param);
381 
    });
382 
 
383 
    asyncTest('always', function () {
384 
        expect(2);
385 
        var param = {files: [{name: 'test'}]},
386 
            counter = 0,
387 
            fu = $('#fileupload').fileupload({
388 
                always: function (e, data) {
389 
                    ok(true, 'Triggers always callback');
390 
                    if (counter === 1) {
391 
                        start();
392 
                    } else {
393 
                        counter += 1;
394 
                    }
395 
                }
396 
            });
397 
        (fu.data('blueimp-fileupload') || fu.data('fileupload'))
398 
            ._isXHRUpload = function () {
399 
                return true;
400 
            };
401 
        fu.fileupload('add', param).fileupload(
402 
            'option',
403 
            'url',
404 
            '404'
405 
        ).fileupload('add', param);
406 
    });
407 
 
408 
    asyncTest('progress', function () {
409 
        expect(1);
410 
        var param = {files: [{name: 'test'}]},
411 
            counter = 0;
412 
        $('#fileupload').fileupload({
413 
            forceIframeTransport: true,
414 
            progress: function (e, data) {
415 
                ok(true, 'Triggers progress callback');
416 
                if (counter === 0) {
417 
                    start();
418 
                } else {
419 
                    counter += 1;
420 
                }
421 
            }
422 
        }).fileupload('send', param);
423 
    });
424 
 
425 
    asyncTest('progressall', function () {
426 
        expect(1);
427 
        var param = {files: [{name: 'test'}]},
428 
            counter = 0;
429 
        $('#fileupload').fileupload({
430 
            forceIframeTransport: true,
431 
            progressall: function (e, data) {
432 
                ok(true, 'Triggers progressall callback');
433 
                if (counter === 0) {
434 
                    start();
435 
                } else {
436 
                    counter += 1;
437 
                }
438 
            }
439 
        }).fileupload('send', param);
440 
    });
441 
 
442 
    asyncTest('start', function () {
443 
        expect(1);
444 
        var param = {files: [{name: '1'}, {name: '2'}]},
445 
            active = 0;
446 
        $('#fileupload').fileupload({
447 
            send: function (e, data) {
448 
                active += 1;
449 
            },
450 
            start: function (e, data) {
451 
                ok(!active, 'Triggers start callback before uploads');
452 
                start();
453 
            }
454 
        }).fileupload('send', param);
455 
    });
456 
 
457 
    asyncTest('stop', function () {
458 
        expect(1);
459 
        var param = {files: [{name: '1'}, {name: '2'}]},
460 
            active = 0;
461 
        $('#fileupload').fileupload({
462 
            send: function (e, data) {
463 
                active += 1;
464 
            },
465 
            always: function (e, data) {
466 
                active -= 1;
467 
            },
468 
            stop: function (e, data) {
469 
                ok(!active, 'Triggers stop callback after uploads');
470 
                start();
471 
            }
472 
        }).fileupload('send', param);
473 
    });
474 
 
475 
    test('change', function () {
476 
        var fu = $('#fileupload').fileupload(),
477 
            fuo = fu.data('blueimp-fileupload') || fu.data('fileupload'),
478 
            fileInput = fu.fileupload('option', 'fileInput');
479 
        expect(2);
480 
        fu.fileupload({
481 
            change: function (e, data) {
482 
                ok(true, 'Triggers change callback');
483 
                strictEqual(
484 
                    data.files.length,
485 
                    0,
486 
                    'Returns empty files list'
487 
                );
488 
            },
489 
            add: $.noop
490 
        });
491 
        fuo._onChange({
492 
            data: {fileupload: fuo},
493 
            target: fileInput[0]
494 
        });
495 
    });
496 
 
497 
    test('paste', function () {
498 
        var fu = $('#fileupload').fileupload(),
499 
            fuo = fu.data('blueimp-fileupload') || fu.data('fileupload');
500 
        expect(1);
501 
        fu.fileupload({
502 
            paste: function (e, data) {
503 
                ok(true, 'Triggers paste callback');
504 
            },
505 
            add: $.noop
506 
        });
507 
        fuo._onPaste({
508 
            data: {fileupload: fuo},
509 
            originalEvent: {clipboardData: {}},
510 
            preventDefault: $.noop
511 
        });
512 
    });
513 
 
514 
    test('drop', function () {
515 
        var fu = $('#fileupload').fileupload(),
516 
            fuo = fu.data('blueimp-fileupload') || fu.data('fileupload');
517 
        expect(1);
518 
        fu.fileupload({
519 
            drop: function (e, data) {
520 
                ok(true, 'Triggers drop callback');
521 
            },
522 
            add: $.noop
523 
        });
524 
        fuo._onDrop({
525 
            data: {fileupload: fuo},
526 
            originalEvent: {dataTransfer: {}},
527 
            preventDefault: $.noop
528 
        });
529 
    });
530 
 
531 
    test('dragover', function () {
532 
        var fu = $('#fileupload').fileupload(),
533 
            fuo = fu.data('blueimp-fileupload') || fu.data('fileupload');
534 
        expect(1);
535 
        fu.fileupload({
536 
            dragover: function (e, data) {
537 
                ok(true, 'Triggers dragover callback');
538 
            },
539 
            add: $.noop
540 
        });
541 
        fuo._onDragOver({
542 
            data: {fileupload: fuo},
543 
            originalEvent: {dataTransfer: {}},
544 
            preventDefault: $.noop
545 
        });
546 
    });
547 
 
548 
    module('Options', lifecycle);
549 
 
550 
    test('paramName', function () {
551 
        expect(1);
552 
        var param = {files: [{name: 'test'}]};
553 
        $('#fileupload').fileupload({
554 
            paramName: null,
555 
            send: function (e, data) {
556 
                strictEqual(
557 
                    data.paramName[0],
558 
                    data.fileInput.prop('name'),
559 
                    'Takes paramName from file input field if not set'
560 
                );
561 
                return false;
562 
            }
563 
        }).fileupload('send', param);
564 
    });
565 
 
566 
    test('url', function () {
567 
        expect(1);
568 
        var param = {files: [{name: 'test'}]};
569 
        $('#fileupload').fileupload({
570 
            url: null,
571 
            send: function (e, data) {
572 
                strictEqual(
573 
                    data.url,
574 
                    $(data.fileInput.prop('form')).prop('action'),
575 
                    'Takes url from form action if not set'
576 
                );
577 
                return false;
578 
            }
579 
        }).fileupload('send', param);
580 
    });
581 
 
582 
    test('type', function () {
583 
        expect(2);
584 
        var param = {files: [{name: 'test'}]};
585 
        $('#fileupload').fileupload({
586 
            type: null,
587 
            send: function (e, data) {
588 
                strictEqual(
589 
                    data.type,
590 
                    'POST',
591 
                    'Request type is "POST" if not set to "PUT"'
592 
                );
593 
                return false;
594 
            }
595 
        }).fileupload('send', param);
596 
        $('#fileupload').fileupload({
597 
            type: 'PUT',
598 
            send: function (e, data) {
599 
                strictEqual(
600 
                    data.type,
601 
                    'PUT',
602 
                    'Request type is "PUT" if set to "PUT"'
603 
                );
604 
                return false;
605 
            }
606 
        }).fileupload('send', param);
607 
    });
608 
 
609 
    test('replaceFileInput', function () {
610 
        var fu = $('#fileupload').fileupload(),
611 
            fuo = fu.data('blueimp-fileupload') || fu.data('fileupload'),
612 
            fileInput = fu.fileupload('option', 'fileInput'),
613 
            fileInputElement = fileInput[0];
614 
        expect(2);
615 
        fu.fileupload({
616 
            replaceFileInput: false,
617 
            change: function (e, data) {
618 
                strictEqual(
619 
                    fu.fileupload('option', 'fileInput')[0],
620 
                    fileInputElement,
621 
                    'Keeps file input with replaceFileInput: false'
622 
                );
623 
            },
624 
            add: $.noop
625 
        });
626 
        fuo._onChange({
627 
            data: {fileupload: fuo},
628 
            target: fileInput[0]
629 
        });
630 
        fu.fileupload({
631 
            replaceFileInput: true,
632 
            change: function (e, data) {
633 
                notStrictEqual(
634 
                    fu.fileupload('option', 'fileInput')[0],
635 
                    fileInputElement,
636 
                    'Replaces file input with replaceFileInput: true'
637 
                );
638 
            },
639 
            add: $.noop
640 
        });
641 
        fuo._onChange({
642 
            data: {fileupload: fuo},
643 
            target: fileInput[0]
644 
        });
645 
    });
646 
 
647 
    asyncTest('forceIframeTransport', function () {
648 
        expect(1);
649 
        var param = {files: [{name: 'test'}]};
650 
        $('#fileupload').fileupload({
651 
            forceIframeTransport: true,
652 
            done: function (e, data) {
653 
                strictEqual(
654 
                    data.dataType.substr(0, 6),
655 
                    'iframe',
656 
                    'Iframe Transport is used'
657 
                );
658 
                start();
659 
            }
660 
        }).fileupload('send', param);
661 
    });
662 
 
663 
    test('singleFileUploads', function () {
664 
        expect(3);
665 
        var fu = $('#fileupload').fileupload(),
666 
            param = {files: [{name: '1'}, {name: '2'}]},
667 
            index = 1;
668 
        (fu.data('blueimp-fileupload') || fu.data('fileupload'))
669 
            ._isXHRUpload = function () {
670 
                return true;
671 
            };
672 
        $('#fileupload').fileupload({
673 
            singleFileUploads: true,
674 
            add: function (e, data) {
675 
                ok(true, 'Triggers callback number ' + index.toString());
676 
                index += 1;
677 
            }
678 
        }).fileupload('add', param).fileupload(
679 
            'option',
680 
            'singleFileUploads',
681 
            false
682 
        ).fileupload('add', param);
683 
    });
684 
 
685 
    test('limitMultiFileUploads', function () {
686 
        expect(3);
687 
        var fu = $('#fileupload').fileupload(),
688 
            param = {files: [
689 
                {name: '1'},
690 
                {name: '2'},
691 
                {name: '3'},
692 
                {name: '4'},
693 
                {name: '5'}
694 
            ]},
695 
            index = 1;
696 
        (fu.data('blueimp-fileupload') || fu.data('fileupload'))
697 
            ._isXHRUpload = function () {
698 
                return true;
699 
            };
700 
        $('#fileupload').fileupload({
701 
            singleFileUploads: false,
702 
            limitMultiFileUploads: 2,
703 
            add: function (e, data) {
704 
                ok(true, 'Triggers callback number ' + index.toString());
705 
                index += 1;
706 
            }
707 
        }).fileupload('add', param);
708 
    });
709 
 
710 
    asyncTest('sequentialUploads', function () {
711 
        expect(6);
712 
        var param = {files: [
713 
                {name: '1'},
714 
                {name: '2'},
715 
                {name: '3'},
716 
                {name: '4'},
717 
                {name: '5'},
718 
                {name: '6'}
719 
            ]},
720 
            addIndex = 0,
721 
            sendIndex = 0,
722 
            loadIndex = 0,
723 
            fu = $('#fileupload').fileupload({
724 
                sequentialUploads: true,
725 
                add: function (e, data) {
726 
                    addIndex += 1;
727 
                    if (addIndex === 4) {
728 
                        data.submit().abort();
729 
                    } else {
730 
                        data.submit();
731 
                    }
732 
                },
733 
                send: function (e, data) {
734 
                    sendIndex += 1;
735 
                },
736 
                done: function (e, data) {
737 
                    loadIndex += 1;
738 
                    strictEqual(sendIndex, loadIndex, 'upload in order');
739 
                },
740 
                fail: function (e, data) {
741 
                    strictEqual(data.errorThrown, 'abort', 'upload aborted');
742 
                },
743 
                stop: function (e) {
744 
                    start();
745 
                }
746 
            });
747 
        (fu.data('blueimp-fileupload') || fu.data('fileupload'))
748 
            ._isXHRUpload = function () {
749 
                return true;
750 
            };
751 
        fu.fileupload('add', param);
752 
    });
753 
 
754 
    asyncTest('limitConcurrentUploads', function () {
755 
        expect(12);
756 
        var param = {files: [
757 
                {name: '1'},
758 
                {name: '2'},
759 
                {name: '3'},
760 
                {name: '4'},
761 
                {name: '5'},
762 
                {name: '6'},
763 
                {name: '7'},
764 
                {name: '8'},
765 
                {name: '9'},
766 
                {name: '10'},
767 
                {name: '11'},
768 
                {name: '12'}
769 
            ]},
770 
            addIndex = 0,
771 
            sendIndex = 0,
772 
            loadIndex = 0,
773 
            fu = $('#fileupload').fileupload({
774 
                limitConcurrentUploads: 3,
775 
                add: function (e, data) {
776 
                    addIndex += 1;
777 
                    if (addIndex === 4) {
778 
                        data.submit().abort();
779 
                    } else {
780 
                        data.submit();
781 
                    }
782 
                },
783 
                send: function (e, data) {
784 
                    sendIndex += 1;
785 
                },
786 
                done: function (e, data) {
787 
                    loadIndex += 1;
788 
                    ok(sendIndex - loadIndex < 3);
789 
                },
790 
                fail: function (e, data) {
791 
                    strictEqual(data.errorThrown, 'abort', 'upload aborted');
792 
                },
793 
                stop: function (e) {
794 
                    start();
795 
                }
796 
            });
797 
        (fu.data('blueimp-fileupload') || fu.data('fileupload'))
798 
            ._isXHRUpload = function () {
799 
                return true;
800 
            };
801 
        fu.fileupload('add', param);
802 
    });
803 
 
804 
    if ($.support.xhrFileUpload) {
805 
        asyncTest('multipart', function () {
806 
            expect(2);
807 
            var param = {files: [{
808 
                    name: 'test.png',
809 
                    size: 123,
810 
                    type: 'image/png'
811 
                }]},
812 
                fu = $('#fileupload').fileupload({
813 
                    multipart: false,
814 
                    always: function (e, data) {
815 
                        strictEqual(
816 
                            data.contentType,
817 
                            param.files[0].type,
818 
                            'non-multipart upload sets file type as contentType'
819 
                        );
820 
                        strictEqual(
821 
                            data.headers['Content-Disposition'],
822 
                            'attachment; filename="' + param.files[0].name + '"',
823 
                            'non-multipart upload sets Content-Disposition header'
824 
                        );
825 
                        start();
826 
                    }
827 
                });
828 
            fu.fileupload('send', param);
829 
        });
830 
    }
831 
 
832 
    module('UI Initialization', lifecycleUI);
833 
 
834 
    test('Widget initialization', function () {
835 
        var fu = $('#fileupload').fileupload();
836 
        ok(fu.data('blueimp-fileupload') || fu.data('fileupload'));
837 
        ok(
838 
            $('#fileupload').fileupload('option', 'uploadTemplate').length,
839 
            'Initialized upload template'
840 
        );
841 
        ok(
842 
            $('#fileupload').fileupload('option', 'downloadTemplate').length,
843 
            'Initialized download template'
844 
        );
845 
    });
846 
 
847 
    test('Buttonbar event listeners', function () {
848 
        var buttonbar = $('#fileupload .fileupload-buttonbar'),
849 
            files = [{name: 'test'}];
850 
        expect(4);
851 
        $('#fileupload').fileupload({
852 
            send: function (e, data) {
853 
                ok(true, 'Started file upload via global start button');
854 
            },
855 
            fail: function (e, data) {
856 
                ok(true, 'Canceled file upload via global cancel button');
857 
                data.context.remove();
858 
            },
859 
            destroy: function (e, data) {
860 
                ok(true, 'Delete action called via global delete button');
861 
            }
862 
        });
863 
        $('#fileupload').fileupload('add', {files: files});
864 
        buttonbar.find('.cancel').click();
865 
        $('#fileupload').fileupload('add', {files: files});
866 
        buttonbar.find('.start').click();
867 
        buttonbar.find('.cancel').click();
868 
        ($('#fileupload').data('blueimp-fileupload') ||
869 
                $('#fileupload').data('fileupload'))
870 
            ._renderDownload(files)
871 
            .appendTo($('#fileupload .files')).show()
872 
            .find('.delete input').click();
873 
        buttonbar.find('.delete').click();
874 
    });
875 
 
876 
    module('UI API', lifecycleUI);
877 
 
878 
    test('destroy', function () {
879 
        var buttonbar = $('#fileupload .fileupload-buttonbar'),
880 
            files = [{name: 'test'}];
881 
        expect(1);
882 
        $('#fileupload').fileupload({
883 
            send: function (e, data) {
884 
                ok(true, 'This test should not run');
885 
                return false;
886 
            }
887 
        })
888 
            .fileupload('add', {files: files})
889 
            .fileupload('destroy');
890 
        buttonbar.find('.start').click(function () {
891 
            ok(true, 'Clicked global start button');
892 
            return false;
893 
        }).click();
894 
    });
895 
 
896 
    test('disable/enable', function () {
897 
        var buttonbar = $('#fileupload .fileupload-buttonbar');
898 
        $('#fileupload').fileupload();
899 
        $('#fileupload').fileupload('disable');
900 
        strictEqual(
901 
            buttonbar.find('input[type=file], button').not(':disabled').length,
902 
            0,
903 
            'Disables the buttonbar buttons'
904 
        );
905 
        $('#fileupload').fileupload('enable');
906 
        strictEqual(
907 
            buttonbar.find('input[type=file], button').not(':disabled').length,
908 
            4,
909 
            'Enables the buttonbar buttons'
910 
        );
911 
    });
912 
 
913 
    module('UI Callbacks', lifecycleUI);
914 
 
915 
    test('destroy', function () {
916 
        expect(3);
917 
        $('#fileupload').fileupload({
918 
            destroy: function (e, data) {
919 
                ok(true, 'Triggers destroy callback');
920 
                strictEqual(
921 
                    data.url,
922 
                    'test',
923 
                    'Passes over deletion url parameter'
924 
                );
925 
                strictEqual(
926 
                    data.type,
927 
                    'DELETE',
928 
                    'Passes over deletion request type parameter'
929 
                );
930 
            }
931 
        });
932 
        ($('#fileupload').data('blueimp-fileupload') ||
933 
                $('#fileupload').data('fileupload'))
934 
            ._renderDownload([{
935 
                name: 'test',
936 
                delete_url: 'test',
937 
                delete_type: 'DELETE'
938 
            }])
939 
            .appendTo($('#fileupload .files'))
940 
            .show()
941 
            .find('.delete input').click();
942 
        $('#fileupload .fileupload-buttonbar .delete').click();
943 
    });
944 
 
945 
    asyncTest('added', function () {
946 
        expect(1);
947 
        var param = {files: [{name: 'test'}]};
948 
        $('#fileupload').fileupload({
949 
            added: function (e, data) {
950 
                start();
951 
                strictEqual(
952 
                    data.files[0].name,
953 
                    param.files[0].name,
954 
                    'Triggers added callback'
955 
                );
956 
            },
957 
            send: function () {
958 
                return false;
959 
            }
960 
        }).fileupload('add', param);
961 
    });
962 
 
963 
    asyncTest('started', function () {
964 
        expect(1);
965 
        var param = {files: [{name: 'test'}]};
966 
        $('#fileupload').fileupload({
967 
            started: function (e) {
968 
                start();
969 
                ok('Triggers started callback');
970 
                return false;
971 
            },
972 
            sent: function (e, data) {
973 
                return false;
974 
            }
975 
        }).fileupload('send', param);
976 
    });
977 
 
978 
    asyncTest('sent', function () {
979 
        expect(1);
980 
        var param = {files: [{name: 'test'}]};
981 
        $('#fileupload').fileupload({
982 
            sent: function (e, data) {
983 
                start();
984 
                strictEqual(
985 
                    data.files[0].name,
986 
                    param.files[0].name,
987 
                    'Triggers sent callback'
988 
                );
989 
                return false;
990 
            }
991 
        }).fileupload('send', param);
992 
    });
993 
 
994 
    asyncTest('completed', function () {
995 
        expect(1);
996 
        var param = {files: [{name: 'test'}]};
997 
        $('#fileupload').fileupload({
998 
            completed: function (e, data) {
999 
                start();
1000 
                ok('Triggers completed callback');
1001 
                return false;
1002 
            }
1003 
        }).fileupload('send', param);
1004 
    });
1005 
 
1006 
    asyncTest('failed', function () {
1007 
        expect(1);
1008 
        var param = {files: [{name: 'test'}]};
1009 
        $('#fileupload').fileupload({
1010 
            failed: function (e, data) {
1011 
                start();
1012 
                ok('Triggers failed callback');
1013 
                return false;
1014 
            }
1015 
        }).fileupload('send', param).abort();
1016 
    });
1017 
 
1018 
    asyncTest('stopped', function () {
1019 
        expect(1);
1020 
        var param = {files: [{name: 'test'}]};
1021 
        $('#fileupload').fileupload({
1022 
            stopped: function (e, data) {
1023 
                start();
1024 
                ok('Triggers stopped callback');
1025 
                return false;
1026 
            }
1027 
        }).fileupload('send', param);
1028 
    });
1029 
 
1030 
    asyncTest('destroyed', function () {
1031 
        expect(1);
1032 
        $('#fileupload').fileupload({
1033 
            destroyed: function (e, data) {
1034 
                start();
1035 
                ok(true, 'Triggers destroyed callback');
1036 
            }
1037 
        });
1038 
        ($('#fileupload').data('blueimp-fileupload') ||
1039 
                $('#fileupload').data('fileupload'))
1040 
            ._renderDownload([{
1041 
                name: 'test',
1042 
                delete_url: 'test',
1043 
                delete_type: 'DELETE'
1044 
            }])
1045 
            .appendTo($('#fileupload .files'))
1046 
            .show()
1047 
            .find('.delete input').click();
1048 
        $('#fileupload .fileupload-buttonbar .delete').click();
1049 
    });
1050 
 
1051 
    module('UI Options', lifecycleUI);
1052 
 
1053 
    test('autoUpload', function () {
1054 
        expect(1);
1055 
        $('#fileupload')
1056 
            .fileupload({
1057 
                autoUpload: true,
1058 
                send: function (e, data) {
1059 
                    ok(true, 'Started file upload automatically');
1060 
                    return false;
1061 
                }
1062 
            })
1063 
            .fileupload('add', {files: [{name: 'test'}]})
1064 
            .fileupload('option', 'autoUpload', false)
1065 
            .fileupload('add', {files: [{name: 'test'}]});
1066 
    });
1067 
 
1068 
    test('maxNumberOfFiles', function () {
1069 
        expect(4);
1070 
        var addIndex = 0,
1071 
            sendIndex = 0;
1072 
        $('#fileupload')
1073 
            .fileupload({
1074 
                autoUpload: true,
1075 
                maxNumberOfFiles: 1,
1076 
                singleFileUploads: false,
1077 
                send: function (e, data) {
1078 
                    strictEqual(
1079 
                        sendIndex += 1,
1080 
                        addIndex
1081 
                    );
1082 
                },
1083 
                progress: $.noop,
1084 
                progressall: $.noop,
1085 
                done: $.noop,
1086 
                stop: $.noop
1087 
            })
1088 
            .fileupload('add', {files: [{name: (addIndex += 1)}]})
1089 
            .fileupload('add', {files: [{name: 'test'}]})
1090 
            .fileupload('option', 'maxNumberOfFiles', 1)
1091 
            .fileupload('add', {files: [{name: 1}, {name: 2}]})
1092 
            .fileupload({
1093 
                maxNumberOfFiles: 1,
1094 
                send: function (e, data) {
1095 
                    strictEqual(
1096 
                        sendIndex += 1,
1097 
                        addIndex
1098 
                    );
1099 
                    return false;
1100 
                }
1101 
            })
1102 
            .fileupload('add', {files: [{name: (addIndex += 1)}]})
1103 
            .fileupload('add', {files: [{name: (addIndex += 1)}]})
1104 
            .fileupload({
1105 
                maxNumberOfFiles: 0,
1106 
                send: function (e, data) {
1107 
                    ok(
1108 
                        !$.blueimp.fileupload.prototype.options
1109 
                            .send.call(this, e, data)
1110 
                    );
1111 
                    return false;
1112 
                }
1113 
            })
1114 
            .fileupload('send', {files: [{name: 'test'}]});
1115 
    });
1116 
 
1117 
    test('maxFileSize', function () {
1118 
        expect(3);
1119 
        var addIndex = 0,
1120 
            sendIndex = 0;
1121 
        $('#fileupload')
1122 
            .fileupload({
1123 
                autoUpload: true,
1124 
                maxFileSize: 1000,
1125 
                send: function (e, data) {
1126 
                    strictEqual(
1127 
                        sendIndex += 1,
1128 
                        addIndex
1129 
                    );
1130 
                    return false;
1131 
                }
1132 
            })
1133 
            .fileupload('add', {files: [{
1134 
                name: (addIndex += 1)
1135 
            }]})
1136 
            .fileupload('add', {files: [{
1137 
                name: (addIndex += 1),
1138 
                size: 999
1139 
            }]})
1140 
            .fileupload('add', {files: [{
1141 
                name: 'test',
1142 
                size: 1001
1143 
            }]})
1144 
            .fileupload({
1145 
                send: function (e, data) {
1146 
                    ok(
1147 
                        !$.blueimp.fileupload.prototype.options
1148 
                            .send.call(this, e, data)
1149 
                    );
1150 
                    return false;
1151 
                }
1152 
            })
1153 
            .fileupload('send', {files: [{
1154 
                name: 'test',
1155 
                size: 1001
1156 
            }]});
1157 
    });
1158 
 
1159 
    test('minFileSize', function () {
1160 
        expect(3);
1161 
        var addIndex = 0,
1162 
            sendIndex = 0;
1163 
        $('#fileupload')
1164 
            .fileupload({
1165 
                autoUpload: true,
1166 
                minFileSize: 1000,
1167 
                send: function (e, data) {
1168 
                    strictEqual(
1169 
                        sendIndex += 1,
1170 
                        addIndex
1171 
                    );
1172 
                    return false;
1173 
                }
1174 
            })
1175 
            .fileupload('add', {files: [{
1176 
                name: (addIndex += 1)
1177 
            }]})
1178 
            .fileupload('add', {files: [{
1179 
                name: (addIndex += 1),
1180 
                size: 1001
1181 
            }]})
1182 
            .fileupload('add', {files: [{
1183 
                name: 'test',
1184 
                size: 999
1185 
            }]})
1186 
            .fileupload({
1187 
                send: function (e, data) {
1188 
                    ok(
1189 
                        !$.blueimp.fileupload.prototype.options
1190 
                            .send.call(this, e, data)
1191 
                    );
1192 
                    return false;
1193 
                }
1194 
            })
1195 
            .fileupload('send', {files: [{
1196 
                name: 'test',
1197 
                size: 999
1198 
            }]});
1199 
    });
1200 
 
1201 
    test('acceptFileTypes', function () {
1202 
        expect(3);
1203 
        var addIndex = 0,
1204 
            sendIndex = 0;
1205 
        $('#fileupload')
1206 
            .fileupload({
1207 
                autoUpload: true,
1208 
                acceptFileTypes: /(\.|\/)(gif|jpe?g|png)$/i,
1209 
                previewFileTypes: /none/,
1210 
                send: function (e, data) {
1211 
                    strictEqual(
1212 
                        sendIndex += 1,
1213 
                        addIndex
1214 
                    );
1215 
                    return false;
1216 
                }
1217 
            })
1218 
            .fileupload('add', {files: [{
1219 
                name: (addIndex += 1) + '.jpg'
1220 
            }]})
1221 
            .fileupload('add', {files: [{
1222 
                name: (addIndex += 1),
1223 
                type: 'image/jpeg'
1224 
            }]})
1225 
            .fileupload('add', {files: [{
1226 
                name: 'test.txt',
1227 
                type: 'text/plain'
1228 
            }]})
1229 
            .fileupload({
1230 
                send: function (e, data) {
1231 
                    ok(
1232 
                        !$.blueimp.fileupload.prototype.options
1233 
                            .send.call(this, e, data)
1234 
                    );
1235 
                    return false;
1236 
                }
1237 
            })
1238 
            .fileupload('send', {files: [{
1239 
                name: 'test.txt',
1240 
                type: 'text/plain'
1241 
            }]});
1242 
    });
1243 
 
1244 
    test('acceptFileTypes as HTML5 data attribute', function () {
1245 
        expect(2);
1246 
        var regExp = /(\.|\/)(gif|jpe?g|png)$/i;
1247 
        $('#fileupload')
1248 
            .attr('data-accept-file-types', regExp.toString())
1249 
            .fileupload();
1250 
        strictEqual(
1251 
            $.type($('#fileupload').fileupload('option', 'acceptFileTypes')),
1252 
            $.type(regExp)
1253 
        );
1254 
        strictEqual(
1255 
            $('#fileupload').fileupload('option', 'acceptFileTypes').toString(),
1256 
            regExp.toString()
1257 
        );
1258 
    });
1259 
 
1260 
});