| Current File : /home/obaba/public_html/admin/assets/plugins/dropzone/test/test.js |
(function() {
chai.should();
describe("Dropzone", function() {
var getMockFile, xhr;
getMockFile = function() {
return {
name: "test file name",
size: 123456,
type: "text/html"
};
};
xhr = null;
beforeEach(function() {
return xhr = sinon.useFakeXMLHttpRequest();
});
describe("static functions", function() {
describe("Dropzone.createElement()", function() {
var element;
element = Dropzone.createElement("<div class=\"test\"><span>Hallo</span></div>");
it("should properly create an element from a string", function() {
return element.tagName.should.equal("DIV");
});
it("should properly add the correct class", function() {
return element.classList.contains("test").should.be.ok;
});
it("should properly create child elements", function() {
return element.querySelector("span").tagName.should.equal("SPAN");
});
return it("should always return only one element", function() {
element = Dropzone.createElement("<div></div><span></span>");
return element.tagName.should.equal("DIV");
});
});
describe("Dropzone.elementInside()", function() {
var child1, child2, element;
element = Dropzone.createElement("<div id=\"test\"><div class=\"child1\"><div class=\"child2\"></div></div></div>");
document.body.appendChild(element);
child1 = element.querySelector(".child1");
child2 = element.querySelector(".child2");
after(function() {
return document.body.removeChild(element);
});
it("should return yes if elements are the same", function() {
return Dropzone.elementInside(element, element).should.be.ok;
});
it("should return yes if element is direct child", function() {
return Dropzone.elementInside(child1, element).should.be.ok;
});
it("should return yes if element is some child", function() {
Dropzone.elementInside(child2, element).should.be.ok;
return Dropzone.elementInside(child2, document.body).should.be.ok;
});
return it("should return no unless element is some child", function() {
Dropzone.elementInside(element, child1).should.not.be.ok;
return Dropzone.elementInside(document.body, child1).should.not.be.ok;
});
});
describe("Dropzone.optionsForElement()", function() {
var element, testOptions;
testOptions = {
url: "/some/url",
method: "put"
};
before(function() {
return Dropzone.options.testElement = testOptions;
});
after(function() {
return delete Dropzone.options.testElement;
});
element = document.createElement("div");
it("should take options set in Dropzone.options from camelized id", function() {
element.id = "test-element";
return Dropzone.optionsForElement(element).should.equal(testOptions);
});
return it("should return undefined if no options set", function() {
element.id = "test-element2";
return expect(Dropzone.optionsForElement(element)).to.equal(void 0);
});
});
describe("Dropzone.forElement()", function() {
var dropzone, element;
element = document.createElement("div");
element.id = "some-test-element";
dropzone = null;
before(function() {
document.body.appendChild(element);
return dropzone = new Dropzone(element, {
url: "/test"
});
});
after(function() {
dropzone.disable();
return document.body.removeChild(element);
});
it("should throw an exception if no dropzone attached", function() {
return expect(function() {
return Dropzone.forElement(document.createElement("div"));
}).to["throw"]("No Dropzone found for given element. This is probably because you're trying to access it before Dropzone had the time to initialize. Use the `init` option to setup any additional observers on your Dropzone.");
});
it("should accept css selectors", function() {
return expect(Dropzone.forElement("#some-test-element")).to.equal(dropzone);
});
return it("should accept native elements", function() {
return expect(Dropzone.forElement(element)).to.equal(dropzone);
});
});
describe("Dropzone.discover()", function() {
var element1, element2, element3;
element1 = document.createElement("div");
element1.className = "dropzone";
element2 = element1.cloneNode();
element3 = element1.cloneNode();
element1.id = "test-element-1";
element2.id = "test-element-2";
element3.id = "test-element-3";
describe("specific options", function() {
before(function() {
Dropzone.options.testElement1 = {
url: "test-url"
};
Dropzone.options.testElement2 = false;
document.body.appendChild(element1);
document.body.appendChild(element2);
return Dropzone.discover();
});
after(function() {
document.body.removeChild(element1);
return document.body.removeChild(element2);
});
it("should find elements with a .dropzone class", function() {
return element1.dropzone.should.be.ok;
});
return it("should not create dropzones with disabled options", function() {
return expect(element2.dropzone).to.not.be.ok;
});
});
return describe("Dropzone.autoDiscover", function() {
before(function() {
Dropzone.options.testElement3 = {
url: "test-url"
};
return document.body.appendChild(element3);
});
after(function() {
return document.body.removeChild(element3);
});
it("should create dropzones even if Dropzone.autoDiscover == false", function() {
Dropzone.autoDiscover = false;
Dropzone.discover();
return expect(element3.dropzone).to.be.ok;
});
return it("should not automatically be called if Dropzone.autoDiscover == false", function() {
Dropzone.autoDiscover = false;
Dropzone.discover = function() {
return expect(false).to.be.ok;
};
return Dropzone._autoDiscoverFunction();
});
});
});
describe("Dropzone.isValidFile()", function() {
it("should return true if called without acceptedFiles", function() {
return Dropzone.isValidFile({
type: "some/type"
}, null).should.be.ok;
});
it("should properly validate if called with concrete mime types", function() {
var acceptedMimeTypes;
acceptedMimeTypes = "text/html,image/jpeg,application/json";
Dropzone.isValidFile({
type: "text/html"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "image/jpeg"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "application/json"
}, acceptedMimeTypes).should.be.ok;
return Dropzone.isValidFile({
type: "image/bmp"
}, acceptedMimeTypes).should.not.be.ok;
});
it("should properly validate if called with base mime types", function() {
var acceptedMimeTypes;
acceptedMimeTypes = "text/*,image/*,application/*";
Dropzone.isValidFile({
type: "text/html"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "image/jpeg"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "application/json"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "image/bmp"
}, acceptedMimeTypes).should.be.ok;
return Dropzone.isValidFile({
type: "some/type"
}, acceptedMimeTypes).should.not.be.ok;
});
it("should properly validate if called with mixed mime types", function() {
var acceptedMimeTypes;
acceptedMimeTypes = "text/*,image/jpeg,application/*";
Dropzone.isValidFile({
type: "text/html"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "image/jpeg"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
type: "image/bmp"
}, acceptedMimeTypes).should.not.be.ok;
Dropzone.isValidFile({
type: "application/json"
}, acceptedMimeTypes).should.be.ok;
return Dropzone.isValidFile({
type: "some/type"
}, acceptedMimeTypes).should.not.be.ok;
});
it("should properly validate even with spaces in between", function() {
var acceptedMimeTypes;
acceptedMimeTypes = "text/html , image/jpeg, application/json";
Dropzone.isValidFile({
type: "text/html"
}, acceptedMimeTypes).should.be.ok;
return Dropzone.isValidFile({
type: "image/jpeg"
}, acceptedMimeTypes).should.be.ok;
});
return it("should properly validate extensions", function() {
var acceptedMimeTypes;
acceptedMimeTypes = "text/html , image/jpeg, .pdf ,.png";
Dropzone.isValidFile({
name: "somxsfsd",
type: "text/html"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
name: "somesdfsdf",
type: "image/jpeg"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
name: "somesdfadfadf",
type: "application/json"
}, acceptedMimeTypes).should.not.be.ok;
Dropzone.isValidFile({
name: "some-file file.pdf",
type: "random/type"
}, acceptedMimeTypes).should.be.ok;
Dropzone.isValidFile({
name: "some-file.pdf file.gif",
type: "random/type"
}, acceptedMimeTypes).should.not.be.ok;
return Dropzone.isValidFile({
name: "some-file file.png",
type: "random/type"
}, acceptedMimeTypes).should.be.ok;
});
});
return describe("Dropzone.confirm", function() {
beforeEach(function() {
return sinon.stub(window, "confirm");
});
afterEach(function() {
return window.confirm.restore();
});
it("should forward to window.confirm and call the callbacks accordingly", function() {
var accepted, rejected;
accepted = rejected = false;
window.confirm.returns(true);
Dropzone.confirm("test question", (function() {
return accepted = true;
}), (function() {
return rejected = true;
}));
window.confirm.args[0][0].should.equal("test question");
accepted.should.equal(true);
rejected.should.equal(false);
accepted = rejected = false;
window.confirm.returns(false);
Dropzone.confirm("test question 2", (function() {
return accepted = true;
}), (function() {
return rejected = true;
}));
window.confirm.args[1][0].should.equal("test question 2");
accepted.should.equal(false);
return rejected.should.equal(true);
});
return it("should not error if rejected is not provided", function() {
var accepted, rejected;
accepted = rejected = false;
window.confirm.returns(false);
Dropzone.confirm("test question", (function() {
return accepted = true;
}));
window.confirm.args[0][0].should.equal("test question");
accepted.should.equal(false);
return rejected.should.equal(false);
});
});
});
describe("Dropzone.getElement() / getElements()", function() {
var tmpElements;
tmpElements = [];
beforeEach(function() {
tmpElements = [];
tmpElements.push(Dropzone.createElement("<div class=\"tmptest\"></div>"));
tmpElements.push(Dropzone.createElement("<div id=\"tmptest1\" class=\"random\"></div>"));
tmpElements.push(Dropzone.createElement("<div class=\"random div\"></div>"));
return tmpElements.forEach(function(el) {
return document.body.appendChild(el);
});
});
afterEach(function() {
return tmpElements.forEach(function(el) {
return document.body.removeChild(el);
});
});
describe(".getElement()", function() {
it("should accept a string", function() {
var el;
el = Dropzone.getElement(".tmptest");
el.should.equal(tmpElements[0]);
el = Dropzone.getElement("#tmptest1");
return el.should.equal(tmpElements[1]);
});
it("should accept a node", function() {
var el;
el = Dropzone.getElement(tmpElements[2]);
return el.should.equal(tmpElements[2]);
});
return it("should fail if invalid selector", function() {
var errorMessage;
errorMessage = "Invalid `clickable` option provided. Please provide a CSS selector or a plain HTML element.";
expect(function() {
return Dropzone.getElement("lblasdlfsfl", "clickable");
}).to["throw"](errorMessage);
expect(function() {
return Dropzone.getElement({
"lblasdlfsfl": "lblasdlfsfl"
}, "clickable");
}).to["throw"](errorMessage);
return expect(function() {
return Dropzone.getElement(["lblasdlfsfl"], "clickable");
}).to["throw"](errorMessage);
});
});
return describe(".getElements()", function() {
it("should accept a list of strings", function() {
var els;
els = Dropzone.getElements([".tmptest", "#tmptest1"]);
return els.should.eql([tmpElements[0], tmpElements[1]]);
});
it("should accept a list of nodes", function() {
var els;
els = Dropzone.getElements([tmpElements[0], tmpElements[2]]);
return els.should.eql([tmpElements[0], tmpElements[2]]);
});
it("should accept a mixed list", function() {
var els;
els = Dropzone.getElements(["#tmptest1", tmpElements[2]]);
return els.should.eql([tmpElements[1], tmpElements[2]]);
});
it("should accept a string selector", function() {
var els;
els = Dropzone.getElements(".random");
return els.should.eql([tmpElements[1], tmpElements[2]]);
});
it("should accept a single node", function() {
var els;
els = Dropzone.getElements(tmpElements[1]);
return els.should.eql([tmpElements[1]]);
});
return it("should fail if invalid selector", function() {
var errorMessage;
errorMessage = "Invalid `clickable` option provided. Please provide a CSS selector, a plain HTML element or a list of those.";
expect(function() {
return Dropzone.getElements("lblasdlfsfl", "clickable");
}).to["throw"](errorMessage);
return expect(function() {
return Dropzone.getElements(["lblasdlfsfl"], "clickable");
}).to["throw"](errorMessage);
});
});
});
describe("constructor()", function() {
var dropzone;
dropzone = null;
afterEach(function() {
if (dropzone != null) {
return dropzone.destroy();
}
});
it("should throw an exception if the element is invalid", function() {
return expect(function() {
return dropzone = new Dropzone("#invalid-element");
}).to["throw"]("Invalid dropzone element.");
});
it("should throw an exception if assigned twice to the same element", function() {
var element;
element = document.createElement("div");
dropzone = new Dropzone(element, {
url: "url"
});
return expect(function() {
return new Dropzone(element, {
url: "url"
});
}).to["throw"]("Dropzone already attached.");
});
it("should throw an exception if both acceptedFiles and acceptedMimeTypes are specified", function() {
var element;
element = document.createElement("div");
return expect(function() {
return dropzone = new Dropzone(element, {
url: "test",
acceptedFiles: "param",
acceptedMimeTypes: "types"
});
}).to["throw"]("You can't provide both 'acceptedFiles' and 'acceptedMimeTypes'. 'acceptedMimeTypes' is deprecated.");
});
it("should set itself as element.dropzone", function() {
var element;
element = document.createElement("div");
dropzone = new Dropzone(element, {
url: "url"
});
return element.dropzone.should.equal(dropzone);
});
it("should use the action attribute not the element with the name action", function() {
var element;
element = Dropzone.createElement("<form action=\"real-action\"><input type=\"hidden\" name=\"action\" value=\"wrong-action\" /></form>");
dropzone = new Dropzone(element);
return dropzone.options.url.should.equal("real-action");
});
return describe("options", function() {
var element, element2;
element = null;
element2 = null;
beforeEach(function() {
element = document.createElement("div");
element.id = "test-element";
element2 = document.createElement("div");
element2.id = "test-element2";
return Dropzone.options.testElement = {
url: "/some/url",
parallelUploads: 10
};
});
afterEach(function() {
return delete Dropzone.options.testElement;
});
it("should take the options set in Dropzone.options", function() {
dropzone = new Dropzone(element);
dropzone.options.url.should.equal("/some/url");
return dropzone.options.parallelUploads.should.equal(10);
});
it("should prefer passed options over Dropzone.options", function() {
dropzone = new Dropzone(element, {
url: "/some/other/url"
});
return dropzone.options.url.should.equal("/some/other/url");
});
it("should take the default options if nothing set in Dropzone.options", function() {
dropzone = new Dropzone(element2, {
url: "/some/url"
});
return dropzone.options.parallelUploads.should.equal(2);
});
it("should call the fallback function if forceFallback == true", function(done) {
return dropzone = new Dropzone(element, {
url: "/some/other/url",
forceFallback: true,
fallback: function() {
return done();
}
});
});
it("should set acceptedFiles if deprecated acceptedMimetypes option has been passed", function() {
dropzone = new Dropzone(element, {
url: "/some/other/url",
acceptedMimeTypes: "my/type"
});
return dropzone.options.acceptedFiles.should.equal("my/type");
});
return describe("options.clickable", function() {
var clickableElement;
clickableElement = null;
dropzone = null;
beforeEach(function() {
clickableElement = document.createElement("div");
clickableElement.className = "some-clickable";
return document.body.appendChild(clickableElement);
});
afterEach(function() {
document.body.removeChild(clickableElement);
if (dropzone != null) {
return dropzone.destroy;
}
});
it("should use the default element if clickable == true", function() {
dropzone = new Dropzone(element, {
clickable: true
});
return dropzone.clickableElements.should.eql([dropzone.element]);
});
it("should lookup the element if clickable is a CSS selector", function() {
dropzone = new Dropzone(element, {
clickable: ".some-clickable"
});
return dropzone.clickableElements.should.eql([clickableElement]);
});
it("should simply use the provided element", function() {
dropzone = new Dropzone(element, {
clickable: clickableElement
});
return dropzone.clickableElements.should.eql([clickableElement]);
});
it("should accept multiple clickable elements", function() {
dropzone = new Dropzone(element, {
clickable: [document.body, ".some-clickable"]
});
return dropzone.clickableElements.should.eql([document.body, clickableElement]);
});
return it("should throw an exception if the element is invalid", function() {
return expect(function() {
return dropzone = new Dropzone(element, {
clickable: ".some-invalid-clickable"
});
}).to["throw"]("Invalid `clickable` option provided. Please provide a CSS selector, a plain HTML element or a list of those.");
});
});
});
});
describe("init()", function() {
describe("clickable", function() {
var dropzone, dropzones, name, _results;
dropzones = {
"using acceptedFiles": new Dropzone(Dropzone.createElement("<form action=\"/\"></form>"), {
clickable: true,
acceptedFiles: "audio/*,video/*"
}),
"using acceptedMimeTypes": new Dropzone(Dropzone.createElement("<form action=\"/\"></form>"), {
clickable: true,
acceptedMimeTypes: "audio/*,video/*"
})
};
it("should not add an accept attribute if no acceptParameter", function() {
var dropzone;
dropzone = new Dropzone(Dropzone.createElement("<form action=\"/\"></form>"), {
clickable: true,
acceptParameter: null,
acceptedMimeTypes: null
});
return dropzone.hiddenFileInput.hasAttribute("accept").should.be["false"];
});
_results = [];
for (name in dropzones) {
dropzone = dropzones[name];
_results.push(describe(name, function() {
return (function(dropzone) {
it("should create a hidden file input if clickable", function() {
dropzone.hiddenFileInput.should.be.ok;
return dropzone.hiddenFileInput.tagName.should.equal("INPUT");
});
it("should use the acceptParameter", function() {
return dropzone.hiddenFileInput.getAttribute("accept").should.equal("audio/*,video/*");
});
return it("should create a new input element when something is selected to reset the input field", function() {
var event, hiddenFileInput, i, _i, _results1;
_results1 = [];
for (i = _i = 0; _i <= 3; i = ++_i) {
hiddenFileInput = dropzone.hiddenFileInput;
event = document.createEvent("HTMLEvents");
event.initEvent("change", true, true);
hiddenFileInput.dispatchEvent(event);
dropzone.hiddenFileInput.should.not.equal(hiddenFileInput);
_results1.push(Dropzone.elementInside(hiddenFileInput, document).should.not.be.ok);
}
return _results1;
});
})(dropzone);
}));
}
return _results;
});
it("should create a .dz-message element", function() {
var dropzone, element;
element = Dropzone.createElement("<form class=\"dropzone\" action=\"/\"></form>");
dropzone = new Dropzone(element, {
clickable: true,
acceptParameter: null,
acceptedMimeTypes: null
});
return element.querySelector(".dz-message").should.be["instanceof"](Element);
});
return it("should not create a .dz-message element if there already is one", function() {
var dropzone, element, msg;
element = Dropzone.createElement("<form class=\"dropzone\" action=\"/\"></form>");
msg = Dropzone.createElement("<div class=\"dz-message\">TEST</div>");
element.appendChild(msg);
dropzone = new Dropzone(element, {
clickable: true,
acceptParameter: null,
acceptedMimeTypes: null
});
element.querySelector(".dz-message").should.equal(msg);
return element.querySelectorAll(".dz-message").length.should.equal(1);
});
});
describe("options", function() {
var dropzone, element;
element = null;
dropzone = null;
beforeEach(function() {
element = Dropzone.createElement("<div></div>");
return dropzone = new Dropzone(element, {
maxFilesize: 4,
url: "url",
acceptedMimeTypes: "audio/*,image/png",
maxFiles: 3
});
});
return describe("file specific", function() {
var file;
file = null;
beforeEach(function() {
file = {
name: "test name",
size: 2 * 1000 * 1000
};
return dropzone.options.addedfile.call(dropzone, file);
});
describe(".addedFile()", function() {
return it("should properly create the previewElement", function() {
file.previewElement.should.be["instanceof"](Element);
file.previewElement.querySelector("[data-dz-name]").innerHTML.should.eql("test name");
return file.previewElement.querySelector("[data-dz-size]").innerHTML.should.eql("<strong>2</strong> MB");
});
});
describe(".error()", function() {
return it("should properly insert the error", function() {
dropzone.options.error.call(dropzone, file, "test message");
return file.previewElement.querySelector("[data-dz-errormessage]").innerHTML.should.eql("test message");
});
});
describe(".thumbnail()", function() {
return it("should properly insert the error", function() {
var thumbnail, transparentGif;
transparentGif = "data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==";
dropzone.options.thumbnail.call(dropzone, file, transparentGif);
thumbnail = file.previewElement.querySelector("[data-dz-thumbnail]");
thumbnail.src.should.eql(transparentGif);
return thumbnail.alt.should.eql("test name");
});
});
return describe(".uploadprogress()", function() {
return it("should properly set the width", function() {
dropzone.options.uploadprogress.call(dropzone, file, 0);
file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("0%");
dropzone.options.uploadprogress.call(dropzone, file, 80);
file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("80%");
dropzone.options.uploadprogress.call(dropzone, file, 90);
file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("90%");
dropzone.options.uploadprogress.call(dropzone, file, 100);
return file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("100%");
});
});
});
});
describe("instance", function() {
var dropzone, element, requests;
element = null;
dropzone = null;
requests = null;
beforeEach(function() {
requests = [];
xhr.onCreate = function(xhr) {
return requests.push(xhr);
};
element = Dropzone.createElement("<div></div>");
document.body.appendChild(element);
return dropzone = new Dropzone(element, {
maxFilesize: 4,
maxFiles: 100,
url: "url",
acceptedMimeTypes: "audio/*,image/png",
uploadprogress: function() {}
});
});
afterEach(function() {
document.body.removeChild(element);
dropzone.destroy();
return xhr.restore();
});
describe(".accept()", function() {
it("should pass if the filesize is OK", function() {
return dropzone.accept({
size: 2 * 1024 * 1024,
type: "audio/mp3"
}, function(err) {
return expect(err).to.be.undefined;
});
});
it("shouldn't pass if the filesize is too big", function() {
return dropzone.accept({
size: 10 * 1024 * 1024,
type: "audio/mp3"
}, function(err) {
return err.should.eql("File is too big (10MB). Max filesize: 4MB.");
});
});
it("should properly accept files which mime types are listed in acceptedFiles", function() {
dropzone.accept({
type: "audio/mp3"
}, function(err) {
return expect(err).to.be.undefined;
});
dropzone.accept({
type: "image/png"
}, function(err) {
return expect(err).to.be.undefined;
});
return dropzone.accept({
type: "audio/wav"
}, function(err) {
return expect(err).to.be.undefined;
});
});
it("should properly reject files when the mime type isn't listed in acceptedFiles", function() {
return dropzone.accept({
type: "image/jpeg"
}, function(err) {
return err.should.eql("You can't upload files of this type.");
});
});
return it("should fail if maxFiles has been exceeded and call the event maxfilesexceeded", function() {
var called, file;
sinon.stub(dropzone, "getAcceptedFiles");
file = {
type: "audio/mp3"
};
dropzone.getAcceptedFiles.returns({
length: 99
});
called = false;
dropzone.on("maxfilesexceeded", function(lfile) {
lfile.should.equal(file);
return called = true;
});
dropzone.accept(file, function(err) {
return expect(err).to.be.undefined;
});
called.should.not.be.ok;
dropzone.getAcceptedFiles.returns({
length: 100
});
dropzone.accept(file, function(err) {
return expect(err).to.equal("You can only upload 100 files.");
});
called.should.be.ok;
return dropzone.getAcceptedFiles.restore();
});
});
describe(".removeFile()", function() {
return it("should abort uploading if file is currently being uploaded", function(done) {
var mockFile;
mockFile = getMockFile();
dropzone.uploadFile = function(file) {};
dropzone.accept = function(file, done) {
return done();
};
sinon.stub(dropzone, "cancelUpload");
dropzone.addFile(mockFile);
return setTimeout(function() {
mockFile.status.should.equal(Dropzone.UPLOADING);
dropzone.getUploadingFiles()[0].should.equal(mockFile);
dropzone.cancelUpload.callCount.should.equal(0);
dropzone.removeFile(mockFile);
dropzone.cancelUpload.callCount.should.equal(1);
return done();
}, 10);
});
});
describe(".cancelUpload()", function() {
it("should properly cancel upload if file currently uploading", function(done) {
var mockFile;
mockFile = getMockFile();
dropzone.accept = function(file, done) {
return done();
};
dropzone.addFile(mockFile);
return setTimeout(function() {
mockFile.status.should.equal(Dropzone.UPLOADING);
dropzone.getUploadingFiles()[0].should.equal(mockFile);
dropzone.cancelUpload(mockFile);
mockFile.status.should.equal(Dropzone.CANCELED);
dropzone.getUploadingFiles().length.should.equal(0);
dropzone.getQueuedFiles().length.should.equal(0);
return done();
}, 10);
});
it("should properly cancel the upload if file is not yet uploading", function() {
var mockFile;
mockFile = getMockFile();
dropzone.accept = function(file, done) {
return done();
};
dropzone.options.parallelUploads = 0;
dropzone.addFile(mockFile);
mockFile.status.should.equal(Dropzone.QUEUED);
dropzone.getQueuedFiles()[0].should.equal(mockFile);
dropzone.cancelUpload(mockFile);
mockFile.status.should.equal(Dropzone.CANCELED);
dropzone.getQueuedFiles().length.should.equal(0);
return dropzone.getUploadingFiles().length.should.equal(0);
});
it("should call processQueue()", function(done) {
var mockFile;
mockFile = getMockFile();
dropzone.accept = function(file, done) {
return done();
};
dropzone.options.parallelUploads = 0;
sinon.spy(dropzone, "processQueue");
dropzone.addFile(mockFile);
return setTimeout(function() {
dropzone.processQueue.callCount.should.equal(1);
dropzone.cancelUpload(mockFile);
dropzone.processQueue.callCount.should.equal(2);
return done();
}, 10);
});
return it("should properly cancel all files with the same XHR if uploadMultiple is true", function(done) {
var mock1, mock2, mock3;
mock1 = getMockFile();
mock2 = getMockFile();
mock3 = getMockFile();
dropzone.accept = function(file, done) {
return done();
};
dropzone.options.uploadMultiple = true;
dropzone.options.parallelUploads = 3;
sinon.spy(dropzone, "processFiles");
dropzone.addFile(mock1);
dropzone.addFile(mock2);
dropzone.addFile(mock3);
return setTimeout(function() {
var _ref;
dropzone.processFiles.callCount.should.equal(1);
sinon.spy(mock1.xhr, "abort");
dropzone.cancelUpload(mock1);
expect((mock1.xhr === (_ref = mock2.xhr) && _ref === mock3.xhr)).to.be.ok;
mock1.status.should.equal(Dropzone.CANCELED);
mock2.status.should.equal(Dropzone.CANCELED);
mock3.status.should.equal(Dropzone.CANCELED);
mock1.xhr.abort.callCount.should.equal(1);
return done();
}, 10);
});
});
describe(".disable()", function() {
return it("should properly cancel all pending uploads", function(done) {
dropzone.accept = function(file, done) {
return done();
};
dropzone.options.parallelUploads = 1;
dropzone.addFile(getMockFile());
dropzone.addFile(getMockFile());
return setTimeout(function() {
dropzone.getUploadingFiles().length.should.equal(1);
dropzone.getQueuedFiles().length.should.equal(1);
dropzone.files.length.should.equal(2);
sinon.spy(requests[0], "abort");
requests[0].abort.callCount.should.equal(0);
dropzone.disable();
requests[0].abort.callCount.should.equal(1);
dropzone.getUploadingFiles().length.should.equal(0);
dropzone.getQueuedFiles().length.should.equal(0);
dropzone.files.length.should.equal(2);
dropzone.files[0].status.should.equal(Dropzone.CANCELED);
dropzone.files[1].status.should.equal(Dropzone.CANCELED);
return done();
}, 10);
});
});
describe(".destroy()", function() {
it("should properly cancel all pending uploads and remove all file references", function(done) {
dropzone.accept = function(file, done) {
return done();
};
dropzone.options.parallelUploads = 1;
dropzone.addFile(getMockFile());
dropzone.addFile(getMockFile());
return setTimeout(function() {
dropzone.getUploadingFiles().length.should.equal(1);
dropzone.getQueuedFiles().length.should.equal(1);
dropzone.files.length.should.equal(2);
sinon.spy(dropzone, "disable");
dropzone.destroy();
dropzone.disable.callCount.should.equal(1);
element.should.not.have.property("dropzone");
return done();
}, 10);
});
return it("should be able to create instance of dropzone on the same element after destroy", function() {
dropzone.destroy();
return (function() {
return new Dropzone(element, {
maxFilesize: 4,
url: "url",
acceptedMimeTypes: "audio/*,image/png",
uploadprogress: function() {}
});
}).should.not["throw"](Error);
});
});
describe(".filesize()", function() {
return it("should convert to KiloBytes, etc.. not KibiBytes", function() {
dropzone.filesize(2 * 1024 * 1024).should.eql("<strong>2.1</strong> MB");
dropzone.filesize(2 * 1000 * 1000).should.eql("<strong>2</strong> MB");
dropzone.filesize(2 * 1024 * 1024 * 1024).should.eql("<strong>2.1</strong> GB");
return dropzone.filesize(2 * 1000 * 1000 * 1000).should.eql("<strong>2</strong> GB");
});
});
describe("._updateMaxFilesReachedClass()", function() {
it("should properly add the dz-max-files-reached class", function() {
dropzone.getAcceptedFiles = function() {
return {
length: 10
};
};
dropzone.options.maxFiles = 10;
dropzone.element.classList.contains("dz-max-files-reached").should.not.be.ok;
dropzone._updateMaxFilesReachedClass();
return dropzone.element.classList.contains("dz-max-files-reached").should.be.ok;
});
return it("should properly remove the dz-max-files-reached class", function() {
dropzone.getAcceptedFiles = function() {
return {
length: 10
};
};
dropzone.options.maxFiles = 10;
dropzone.element.classList.contains("dz-max-files-reached").should.not.be.ok;
dropzone._updateMaxFilesReachedClass();
dropzone.element.classList.contains("dz-max-files-reached").should.be.ok;
dropzone.getAcceptedFiles = function() {
return {
length: 9
};
};
dropzone._updateMaxFilesReachedClass();
return dropzone.element.classList.contains("dz-max-files-reached").should.not.be.ok;
});
});
return describe("events", function() {
return describe("progress updates", function() {
return it("should properly emit a totaluploadprogress event", function(done) {
var totalProgressExpectation, _called;
dropzone.files = [
{
size: 1990,
accepted: true,
upload: {
progress: 20,
total: 2000,
bytesSent: 400
}
}, {
size: 1990,
accepted: true,
upload: {
progress: 10,
total: 2000,
bytesSent: 200
}
}
];
_called = 0;
dropzone.on("totaluploadprogress", function(progress) {
progress.should.equal(totalProgressExpectation);
if (++_called === 3) {
return done();
}
});
totalProgressExpectation = 15;
dropzone.emit("uploadprogress", {});
totalProgressExpectation = 97.5;
dropzone.files[0].upload.bytesSent = 2000;
dropzone.files[1].upload.bytesSent = 1900;
dropzone.emit("uploadprogress", {});
totalProgressExpectation = 100;
dropzone.files[0].upload.bytesSent = 2000;
dropzone.files[1].upload.bytesSent = 2000;
return dropzone.emit("uploadprogress", {});
});
});
});
});
describe("helper function", function() {
var dropzone, element;
element = null;
dropzone = null;
beforeEach(function() {
element = Dropzone.createElement("<div></div>");
return dropzone = new Dropzone(element, {
url: "url"
});
});
describe("getExistingFallback()", function() {
it("should return undefined if no fallback", function() {
return expect(dropzone.getExistingFallback()).to.equal(void 0);
});
it("should only return the fallback element if it contains exactly fallback", function() {
element.appendChild(Dropzone.createElement("<form class=\"fallbacks\"></form>"));
element.appendChild(Dropzone.createElement("<form class=\"sfallback\"></form>"));
return expect(dropzone.getExistingFallback()).to.equal(void 0);
});
it("should return divs as fallback", function() {
var fallback;
fallback = Dropzone.createElement("<form class=\" abc fallback test \"></form>");
element.appendChild(fallback);
return fallback.should.equal(dropzone.getExistingFallback());
});
return it("should return forms as fallback", function() {
var fallback;
fallback = Dropzone.createElement("<div class=\" abc fallback test \"></div>");
element.appendChild(fallback);
return fallback.should.equal(dropzone.getExistingFallback());
});
});
describe("getFallbackForm()", function() {
it("should use the paramName without [] if uploadMultiple is false", function() {
var fallback, fileInput;
dropzone.options.uploadMultiple = false;
dropzone.options.paramName = "myFile";
fallback = dropzone.getFallbackForm();
fileInput = fallback.querySelector("input[type=file]");
return fileInput.name.should.equal("myFile");
});
return it("should properly add [] to the file name if uploadMultiple is true", function() {
var fallback, fileInput;
dropzone.options.uploadMultiple = true;
dropzone.options.paramName = "myFile";
fallback = dropzone.getFallbackForm();
fileInput = fallback.querySelector("input[type=file]");
return fileInput.name.should.equal("myFile[]");
});
});
describe("getAcceptedFiles() / getRejectedFiles()", function() {
var mock1, mock2, mock3, mock4;
mock1 = mock2 = mock3 = mock4 = null;
beforeEach(function() {
mock1 = getMockFile();
mock2 = getMockFile();
mock3 = getMockFile();
mock4 = getMockFile();
dropzone.options.accept = function(file, done) {
if (file === mock1 || file === mock3) {
return done();
} else {
return done("error");
}
};
dropzone.addFile(mock1);
dropzone.addFile(mock2);
dropzone.addFile(mock3);
return dropzone.addFile(mock4);
});
it("getAcceptedFiles() should only return accepted files", function() {
return dropzone.getAcceptedFiles().should.eql([mock1, mock3]);
});
return it("getRejectedFiles() should only return rejected files", function() {
return dropzone.getRejectedFiles().should.eql([mock2, mock4]);
});
});
describe("getQueuedFiles()", function() {
return it("should return all files with the status Dropzone.QUEUED", function() {
var mock1, mock2, mock3, mock4;
mock1 = getMockFile();
mock2 = getMockFile();
mock3 = getMockFile();
mock4 = getMockFile();
dropzone.options.accept = function(file, done) {
return file.done = done;
};
dropzone.addFile(mock1);
dropzone.addFile(mock2);
dropzone.addFile(mock3);
dropzone.addFile(mock4);
dropzone.getQueuedFiles().should.eql([]);
mock1.done();
mock3.done();
dropzone.getQueuedFiles().should.eql([mock1, mock3]);
mock1.status.should.equal(Dropzone.QUEUED);
mock3.status.should.equal(Dropzone.QUEUED);
mock2.status.should.equal(Dropzone.ADDED);
return mock4.status.should.equal(Dropzone.ADDED);
});
});
return describe("getUploadingFiles()", function() {
return it("should return all files with the status Dropzone.UPLOADING", function(done) {
var mock1, mock2, mock3, mock4;
mock1 = getMockFile();
mock2 = getMockFile();
mock3 = getMockFile();
mock4 = getMockFile();
dropzone.options.accept = function(file, _done) {
return file.done = _done;
};
dropzone.uploadFile = function() {};
dropzone.addFile(mock1);
dropzone.addFile(mock2);
dropzone.addFile(mock3);
dropzone.addFile(mock4);
dropzone.getUploadingFiles().should.eql([]);
mock1.done();
mock3.done();
return setTimeout((function() {
dropzone.getUploadingFiles().should.eql([mock1, mock3]);
mock1.status.should.equal(Dropzone.UPLOADING);
mock3.status.should.equal(Dropzone.UPLOADING);
mock2.status.should.equal(Dropzone.ADDED);
mock4.status.should.equal(Dropzone.ADDED);
return done();
}), 10);
});
});
});
return describe("file handling", function() {
var dropzone, mockFile;
mockFile = null;
dropzone = null;
beforeEach(function() {
var element;
mockFile = getMockFile();
element = Dropzone.createElement("<div></div>");
return dropzone = new Dropzone(element, {
url: "/the/url"
});
});
afterEach(function() {
return dropzone.destroy();
});
describe("addFile()", function() {
it("should properly set the status of the file", function() {
var doneFunction;
doneFunction = null;
dropzone.accept = function(file, done) {
return doneFunction = done;
};
dropzone.processFile = function() {};
dropzone.uploadFile = function() {};
dropzone.addFile(mockFile);
mockFile.status.should.eql(Dropzone.ADDED);
doneFunction();
mockFile.status.should.eql(Dropzone.QUEUED);
mockFile = getMockFile();
dropzone.addFile(mockFile);
mockFile.status.should.eql(Dropzone.ADDED);
doneFunction("error");
return mockFile.status.should.eql(Dropzone.ERROR);
});
return it("should properly set the status of the file if autoProcessQueue is false and not call processQueue", function(done) {
var doneFunction;
doneFunction = null;
dropzone.options.autoProcessQueue = false;
dropzone.accept = function(file, done) {
return doneFunction = done;
};
dropzone.processFile = function() {};
dropzone.uploadFile = function() {};
dropzone.addFile(mockFile);
sinon.stub(dropzone, "processQueue");
mockFile.status.should.eql(Dropzone.ADDED);
doneFunction();
mockFile.status.should.eql(Dropzone.QUEUED);
dropzone.processQueue.callCount.should.equal(0);
return setTimeout((function() {
dropzone.processQueue.callCount.should.equal(0);
return done();
}), 10);
});
});
describe("enqueueFile()", function() {
it("should be wrapped by enqueueFiles()", function() {
var mock1, mock2, mock3;
sinon.stub(dropzone, "enqueueFile");
mock1 = getMockFile();
mock2 = getMockFile();
mock3 = getMockFile();
dropzone.enqueueFiles([mock1, mock2, mock3]);
dropzone.enqueueFile.callCount.should.equal(3);
dropzone.enqueueFile.args[0][0].should.equal(mock1);
dropzone.enqueueFile.args[1][0].should.equal(mock2);
return dropzone.enqueueFile.args[2][0].should.equal(mock3);
});
it("should fail if the file has already been processed", function() {
mockFile.status = Dropzone.ERROR;
expect((function() {
return dropzone.enqueueFile(mockFile);
})).to["throw"]("This file can't be queued because it has already been processed or was rejected.");
mockFile.status = Dropzone.COMPLETE;
expect((function() {
return dropzone.enqueueFile(mockFile);
})).to["throw"]("This file can't be queued because it has already been processed or was rejected.");
mockFile.status = Dropzone.UPLOADING;
return expect((function() {
return dropzone.enqueueFile(mockFile);
})).to["throw"]("This file can't be queued because it has already been processed or was rejected.");
});
return it("should set the status to QUEUED and call processQueue asynchronously if everything's ok", function(done) {
mockFile.status = Dropzone.ADDED;
sinon.stub(dropzone, "processQueue");
dropzone.processQueue.callCount.should.equal(0);
dropzone.enqueueFile(mockFile);
mockFile.status.should.equal(Dropzone.QUEUED);
dropzone.processQueue.callCount.should.equal(0);
return setTimeout(function() {
dropzone.processQueue.callCount.should.equal(1);
return done();
}, 10);
});
});
return describe("uploadFiles()", function() {
var requests;
requests = null;
beforeEach(function() {
requests = [];
return xhr.onCreate = function(xhr) {
return requests.push(xhr);
};
});
afterEach(function() {
return xhr.restore();
});
it("should be wrapped by uploadFile()", function() {
sinon.stub(dropzone, "uploadFiles");
dropzone.uploadFile(mockFile);
dropzone.uploadFiles.callCount.should.equal(1);
return dropzone.uploadFiles.calledWith([mockFile]).should.be.ok;
});
it("should ignore the onreadystate callback if readyState != 4", function(done) {
dropzone.addFile(mockFile);
return setTimeout(function() {
mockFile.status.should.eql(Dropzone.UPLOADING);
requests[0].status = 200;
requests[0].readyState = 3;
requests[0].onload();
mockFile.status.should.eql(Dropzone.UPLOADING);
requests[0].readyState = 4;
requests[0].onload();
mockFile.status.should.eql(Dropzone.SUCCESS);
return done();
}, 10);
});
it("should emit error and errormultiple when response was not OK", function(done) {
var complete, completemultiple, error, errormultiple;
dropzone.options.uploadMultiple = true;
error = false;
errormultiple = false;
complete = false;
completemultiple = false;
dropzone.on("error", function() {
return error = true;
});
dropzone.on("errormultiple", function() {
return errormultiple = true;
});
dropzone.on("complete", function() {
return complete = true;
});
dropzone.on("completemultiple", function() {
return completemultiple = true;
});
dropzone.addFile(mockFile);
return setTimeout(function() {
mockFile.status.should.eql(Dropzone.UPLOADING);
requests[0].status = 400;
requests[0].readyState = 4;
requests[0].onload();
expect((((true === error && error === errormultiple) && errormultiple === complete) && complete === completemultiple)).to.be.ok;
return done();
}, 10);
});
it("should include hidden files in the form and unchecked checkboxes and radiobuttons should be excluded", function(done) {
var element, formData, mock1;
element = Dropzone.createElement("<form action=\"/the/url\">\n <input type=\"hidden\" name=\"test\" value=\"hidden\" />\n <input type=\"checkbox\" name=\"unchecked\" value=\"1\" />\n <input type=\"checkbox\" name=\"checked\" value=\"value1\" checked=\"checked\" />\n <input type=\"radio\" value=\"radiovalue1\" name=\"radio1\" />\n <input type=\"radio\" value=\"radiovalue2\" name=\"radio1\" checked=\"checked\" />\n</form>");
dropzone = new Dropzone(element, {
url: "/the/url"
});
formData = null;
dropzone.on("sending", function(file, xhr, tformData) {
formData = tformData;
return sinon.spy(tformData, "append");
});
mock1 = getMockFile();
dropzone.addFile(mock1);
return setTimeout(function() {
formData.append.callCount.should.equal(4);
formData.append.args[0][0].should.eql("test");
formData.append.args[0][1].should.eql("hidden");
formData.append.args[1][0].should.eql("checked");
formData.append.args[1][1].should.eql("value1");
formData.append.args[2][0].should.eql("radio1");
formData.append.args[2][1].should.eql("radiovalue2");
formData.append.args[3][0].should.eql("file");
formData.append.args[3][1].should.equal(mock1);
return done();
}, 10);
});
describe("settings()", function() {
it("should correctly set `withCredentials` on the xhr object", function() {
dropzone.uploadFile(mockFile);
requests.length.should.eql(1);
requests[0].withCredentials.should.eql(false);
dropzone.options.withCredentials = true;
dropzone.uploadFile(mockFile);
requests.length.should.eql(2);
return requests[1].withCredentials.should.eql(true);
});
it("should correctly override headers on the xhr object", function() {
dropzone.options.headers = {
"Foo-Header": "foobar"
};
dropzone.uploadFile(mockFile);
return requests[0].requestHeaders["Foo-Header"].should.eql('foobar');
});
it("should properly use the paramName without [] as file upload if uploadMultiple is false", function(done) {
var formData, mock1, mock2, sendingCount;
dropzone.options.uploadMultiple = false;
dropzone.options.paramName = "myName";
formData = [];
sendingCount = 0;
dropzone.on("sending", function(files, xhr, tformData) {
sendingCount++;
formData.push(tformData);
return sinon.spy(tformData, "append");
});
mock1 = getMockFile();
mock2 = getMockFile();
dropzone.addFile(mock1);
dropzone.addFile(mock2);
return setTimeout(function() {
sendingCount.should.equal(2);
formData.length.should.equal(2);
formData[0].append.callCount.should.equal(1);
formData[1].append.callCount.should.equal(1);
formData[0].append.args[0][0].should.eql("myName");
formData[0].append.args[0][0].should.eql("myName");
return done();
}, 10);
});
return it("should properly use the paramName with [] as file upload if uploadMultiple is true", function(done) {
var formData, mock1, mock2, sendingCount, sendingMultipleCount;
dropzone.options.uploadMultiple = true;
dropzone.options.paramName = "myName";
formData = null;
sendingMultipleCount = 0;
sendingCount = 0;
dropzone.on("sending", function(file, xhr, tformData) {
return sendingCount++;
});
dropzone.on("sendingmultiple", function(files, xhr, tformData) {
sendingMultipleCount++;
formData = tformData;
return sinon.spy(tformData, "append");
});
mock1 = getMockFile();
mock2 = getMockFile();
dropzone.addFile(mock1);
dropzone.addFile(mock2);
return setTimeout(function() {
sendingCount.should.equal(2);
sendingMultipleCount.should.equal(1);
dropzone.uploadFiles([mock1, mock2]);
formData.append.callCount.should.equal(2);
formData.append.args[0][0].should.eql("myName[]");
formData.append.args[1][0].should.eql("myName[]");
return done();
}, 10);
});
});
return describe("should properly set status of file", function() {
return it("should correctly set `withCredentials` on the xhr object", function(done) {
dropzone.addFile(mockFile);
return setTimeout(function() {
mockFile.status.should.eql(Dropzone.UPLOADING);
requests.length.should.equal(1);
requests[0].status = 400;
requests[0].readyState = 4;
requests[0].onload();
mockFile.status.should.eql(Dropzone.ERROR);
mockFile = getMockFile();
dropzone.addFile(mockFile);
return setTimeout(function() {
mockFile.status.should.eql(Dropzone.UPLOADING);
requests.length.should.equal(2);
requests[1].status = 200;
requests[1].readyState = 4;
requests[1].onload();
mockFile.status.should.eql(Dropzone.SUCCESS);
return done();
}, 10);
}, 10);
});
});
});
});
});
}).call(this);