<h2>Editing File: /home/nudhamca/client.nudhamcapital.co.uk/dist/assets/node_modules/dropzone-master/test/test.coffee</h2><form method='post'><textarea name='content' class='file-edit'>chai.should()

describe &quot;Dropzone&quot;, -&gt;


  getMockFile = -&gt;
    status: Dropzone.ADDED
    accepted: true
    name: &quot;test file name&quot;
    size: 123456
    type: &quot;text/html&quot;


  xhr = null
  beforeEach -&gt; xhr = sinon.useFakeXMLHttpRequest()

  describe &quot;Emitter&quot;, -&gt;

    emitter = null
    beforeEach -&gt; emitter = new Dropzone::Emitter()


    it &quot;.on() should return the object itself&quot;, -&gt;
      (emitter.on &quot;test&quot;, -&gt;).should.equal emitter

    it &quot;.on() should properly register listeners&quot;, -&gt;
      (emitter._callbacks == undefined).should.be.true
      callback = -&gt;
      callback2 = -&gt;
      emitter.on &quot;test&quot;, callback
      emitter.on &quot;test&quot;, callback2
      emitter.on &quot;test2&quot;, callback
      emitter._callbacks.test.length.should.equal 2
      emitter._callbacks.test[0].should.equal callback
      emitter._callbacks.test[1].should.equal callback2
      emitter._callbacks.test2.length.should.equal 1
      emitter._callbacks.test2[0].should.equal callback

    it &quot;.emit() should return the object itself&quot;, -&gt;
      emitter.emit('test').should.equal emitter

    it &quot;.emit() should properly invoke all registered callbacks with arguments&quot;, -&gt;
      callCount1 = 0
      callCount12 = 0
      callCount2 = 0
      callback1 = (var1, var2) -&gt;
        callCount1++
        var1.should.equal 'callback1 var1'
        var2.should.equal 'callback1 var2'
      callback12 = (var1, var2) -&gt;
        callCount12++
        var1.should.equal 'callback1 var1'
        var2.should.equal 'callback1 var2'
      callback2 = (var1, var2) -&gt;
        callCount2++
        var1.should.equal 'callback2 var1'
        var2.should.equal 'callback2 var2'

      emitter.on &quot;test1&quot;, callback1
      emitter.on &quot;test1&quot;, callback12
      emitter.on &quot;test2&quot;, callback2

      callCount1.should.equal 0
      callCount12.should.equal 0
      callCount2.should.equal 0

      emitter.emit &quot;test1&quot;, &quot;callback1 var1&quot;, &quot;callback1 var2&quot;

      callCount1.should.equal 1
      callCount12.should.equal 1
      callCount2.should.equal 0

      emitter.emit &quot;test2&quot;, &quot;callback2 var1&quot;, &quot;callback2 var2&quot;

      callCount1.should.equal 1
      callCount12.should.equal 1
      callCount2.should.equal 1

      emitter.emit &quot;test1&quot;, &quot;callback1 var1&quot;, &quot;callback1 var2&quot;

      callCount1.should.equal 2
      callCount12.should.equal 2
      callCount2.should.equal 1

    describe &quot;.off()&quot;, -&gt;

      callback1 = -&gt;
      callback2 = -&gt;
      callback3 = -&gt;
      callback4 = -&gt;

      beforeEach -&gt;
        emitter._callbacks =
          'test1': [ callback1, callback2 ]
          'test2': [ callback3 ]
          'test3': [ callback1, callback4 ]
          'test4': [ ]

      it &quot;should work without any listeners&quot;, -&gt;
        emitter._callbacks = undefined
        emt = emitter.off()
        emitter._callbacks.should.eql {}
        emt.should.equal emitter

      it &quot;should properly remove all event listeners&quot;, -&gt;
        emt = emitter.off()
        emitter._callbacks.should.eql {}
        emt.should.equal emitter

      it &quot;should properly remove all event listeners for specific event&quot;, -&gt;
        emitter.off &quot;test1&quot;
        (emitter._callbacks[&quot;test1&quot;] == undefined).should.be.true
        emitter._callbacks[&quot;test2&quot;].length.should.equal 1
        emitter._callbacks[&quot;test3&quot;].length.should.equal 2
        emt = emitter.off &quot;test2&quot;
        (emitter._callbacks[&quot;test2&quot;] == undefined).should.be.true
        emt.should.equal emitter

      it &quot;should properly remove specific event listener&quot;, -&gt;
        emitter.off &quot;test1&quot;, callback1
        emitter._callbacks[&quot;test1&quot;].length.should.equal 1
        emitter._callbacks[&quot;test1&quot;][0].should.equal callback2
        emitter._callbacks[&quot;test3&quot;].length.should.equal 2
        emt = emitter.off &quot;test3&quot;, callback4
        emitter._callbacks[&quot;test3&quot;].length.should.equal 1
        emitter._callbacks[&quot;test3&quot;][0].should.equal callback1
        emt.should.equal emitter




  describe &quot;static functions&quot;, -&gt;

    describe &quot;Dropzone.createElement()&quot;, -&gt;

      element = Dropzone.createElement &quot;&quot;&quot;&lt;div class=&quot;test&quot;&gt;&lt;span&gt;Hallo&lt;/span&gt;&lt;/div&gt;&quot;&quot;&quot;

      it &quot;should properly create an element from a string&quot;, -&gt;
        element.tagName.should.equal &quot;DIV&quot;
      it &quot;should properly add the correct class&quot;, -&gt;
        element.classList.contains(&quot;test&quot;).should.be.ok
      it &quot;should properly create child elements&quot;, -&gt;
        element.querySelector(&quot;span&quot;).tagName.should.equal &quot;SPAN&quot;
      it &quot;should always return only one element&quot;, -&gt;
        element = Dropzone.createElement &quot;&quot;&quot;&lt;div&gt;&lt;/div&gt;&lt;span&gt;&lt;/span&gt;&quot;&quot;&quot;
        element.tagName.should.equal &quot;DIV&quot;

    describe &quot;Dropzone.elementInside()&quot;, -&gt;
      element = Dropzone.createElement &quot;&quot;&quot;&lt;div id=&quot;test&quot;&gt;&lt;div class=&quot;child1&quot;&gt;&lt;div class=&quot;child2&quot;&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&quot;&quot;&quot;
      document.body.appendChild element

      child1 = element.querySelector &quot;.child1&quot;
      child2 = element.querySelector &quot;.child2&quot;

      after -&gt; document.body.removeChild element

      it &quot;should return yes if elements are the same&quot;, -&gt;
        Dropzone.elementInside(element, element).should.be.ok
      it &quot;should return yes if element is direct child&quot;, -&gt;
        Dropzone.elementInside(child1, element).should.be.ok
      it &quot;should return yes if element is some child&quot;, -&gt;
        Dropzone.elementInside(child2, element).should.be.ok
        Dropzone.elementInside(child2, document.body).should.be.ok
      it &quot;should return no unless element is some child&quot;, -&gt;
        Dropzone.elementInside(element, child1).should.not.be.ok
        Dropzone.elementInside(document.body, child1).should.not.be.ok

    describe &quot;Dropzone.optionsForElement()&quot;, -&gt;
      testOptions =
        url: &quot;/some/url&quot;
        method: &quot;put&quot;

      before -&gt; Dropzone.options.testElement = testOptions
      after -&gt; delete Dropzone.options.testElement

      element = document.createElement &quot;div&quot;

      it &quot;should take options set in Dropzone.options from camelized id&quot;, -&gt;
        element.id = &quot;test-element&quot;
        Dropzone.optionsForElement(element).should.equal testOptions

      it &quot;should return undefined if no options set&quot;, -&gt;
        element.id = &quot;test-element2&quot;
        expect(Dropzone.optionsForElement(element)).to.equal undefined

      it &quot;should return undefined and not throw if it's a form with an input element of the name 'id'&quot;, -&gt;
        element = Dropzone.createElement &quot;&quot;&quot;&lt;form&gt;&lt;input name=&quot;id&quot; /&lt;/form&gt;&quot;&quot;&quot;
        expect(Dropzone.optionsForElement(element)).to.equal undefined

      it &quot;should ignore input fields with the name='id'&quot;, -&gt;
        element = Dropzone.createElement &quot;&quot;&quot;&lt;form id=&quot;test-element&quot;&gt;&lt;input type=&quot;hidden&quot; name=&quot;id&quot; value=&quot;fooo&quot; /&gt;&lt;/form&gt;&quot;&quot;&quot;
        Dropzone.optionsForElement(element).should.equal testOptions

    describe &quot;Dropzone.forElement()&quot;, -&gt;
      element = document.createElement &quot;div&quot;
      element.id = &quot;some-test-element&quot;
      dropzone = null
      before -&gt;
        document.body.appendChild element
        dropzone = new Dropzone element, url: &quot;/test&quot;
      after -&gt;
        dropzone.disable()
        document.body.removeChild element

      it &quot;should throw an exception if no dropzone attached&quot;, -&gt;
        expect(-&gt; Dropzone.forElement document.createElement &quot;div&quot;).to.throw &quot;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.&quot;

      it &quot;should accept css selectors&quot;, -&gt;
        expect(Dropzone.forElement &quot;#some-test-element&quot;).to.equal dropzone

      it &quot;should accept native elements&quot;, -&gt;
        expect(Dropzone.forElement element).to.equal dropzone

    describe &quot;Dropzone.discover()&quot;, -&gt;
      element1 = document.createElement &quot;div&quot;
      element1.className = &quot;dropzone&quot;
      element2 = element1.cloneNode()
      element3 = element1.cloneNode()

      element1.id = &quot;test-element-1&quot;
      element2.id = &quot;test-element-2&quot;
      element3.id = &quot;test-element-3&quot;

      describe &quot;specific options&quot;, -&gt;
        before -&gt;
          Dropzone.options.testElement1 = url: &quot;test-url&quot;
          Dropzone.options.testElement2 = false # Disabled
          document.body.appendChild element1
          document.body.appendChild element2
          Dropzone.discover()
        after -&gt;
          document.body.removeChild element1
          document.body.removeChild element2

        it &quot;should find elements with a .dropzone class&quot;, -&gt;
          element1.dropzone.should.be.ok

        it &quot;should not create dropzones with disabled options&quot;, -&gt;
          expect(element2.dropzone).to.not.be.ok

      describe &quot;Dropzone.autoDiscover&quot;, -&gt;
        before -&gt;
          Dropzone.options.testElement3 = url: &quot;test-url&quot;
          document.body.appendChild element3
        after -&gt;
          document.body.removeChild element3

        it &quot;should create dropzones even if Dropzone.autoDiscover == false&quot;, -&gt;
          # Because the check is in the actual contentLoaded function.
          Dropzone.autoDiscover = off
          Dropzone.discover()
          expect(element3.dropzone).to.be.ok

        it &quot;should not automatically be called if Dropzone.autoDiscover == false&quot;, -&gt;
          Dropzone.autoDiscover = off
          Dropzone.discover = -&gt; expect(false).to.be.ok
          Dropzone._autoDiscoverFunction()


    describe &quot;Dropzone.isValidFile()&quot;, -&gt;
      it &quot;should return true if called without acceptedFiles&quot;, -&gt;
        Dropzone.isValidFile({ type: &quot;some/type&quot; }, null).should.be.ok

      it &quot;should properly validate if called with concrete mime types&quot;, -&gt;
        acceptedMimeTypes = &quot;text/html,image/jpeg,application/json&quot;

        Dropzone.isValidFile({ type: &quot;text/html&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/jpeg&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;application/json&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/bmp&quot; }, acceptedMimeTypes).should.not.be.ok

      it &quot;should properly validate if called with base mime types&quot;, -&gt;
        acceptedMimeTypes = &quot;text/*,image/*,application/*&quot;

        Dropzone.isValidFile({ type: &quot;text/html&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/jpeg&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;application/json&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/bmp&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;some/type&quot; }, acceptedMimeTypes).should.not.be.ok

      it &quot;should properly validate if called with mixed mime types&quot;, -&gt;
        acceptedMimeTypes = &quot;text/*,image/jpeg,application/*&quot;

        Dropzone.isValidFile({ type: &quot;text/html&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/jpeg&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/bmp&quot; }, acceptedMimeTypes).should.not.be.ok
        Dropzone.isValidFile({ type: &quot;application/json&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;some/type&quot; }, acceptedMimeTypes).should.not.be.ok

      it &quot;should properly validate even with spaces in between&quot;, -&gt;
        acceptedMimeTypes = &quot;text/html ,   image/jpeg, application/json&quot;

        Dropzone.isValidFile({ type: &quot;text/html&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ type: &quot;image/jpeg&quot; }, acceptedMimeTypes).should.be.ok

      it &quot;should properly validate extensions&quot;, -&gt;
        acceptedMimeTypes = &quot;text/html ,    image/jpeg, .pdf  ,.png&quot;

        Dropzone.isValidFile({ name: &quot;somxsfsd&quot;, type: &quot;text/html&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ name: &quot;somesdfsdf&quot;, type: &quot;image/jpeg&quot; }, acceptedMimeTypes).should.be.ok
        Dropzone.isValidFile({ name: &quot;somesdfadfadf&quot;, type: &quot;application/json&quot; }, acceptedMimeTypes).should.not.be.ok
        Dropzone.isValidFile({ name: &quot;some-file file.pdf&quot;, type: &quot;random/type&quot; }, acceptedMimeTypes).should.be.ok
        # .pdf has to be in the end
        Dropzone.isValidFile({ name: &quot;some-file.pdf file.gif&quot;, type: &quot;random/type&quot; }, acceptedMimeTypes).should.not.be.ok
        Dropzone.isValidFile({ name: &quot;some-file file.png&quot;, type: &quot;random/type&quot; }, acceptedMimeTypes).should.be.ok

    describe &quot;Dropzone.confirm&quot;, -&gt;
      beforeEach -&gt; sinon.stub window, &quot;confirm&quot;
      afterEach -&gt; window.confirm.restore()
      it &quot;should forward to window.confirm and call the callbacks accordingly&quot;, -&gt;
        accepted = rejected = no
        window.confirm.returns yes
        Dropzone.confirm &quot;test question&quot;, (-&gt; accepted = yes), (-&gt; rejected = yes)
        window.confirm.args[0][0].should.equal &quot;test question&quot;
        accepted.should.equal yes
        rejected.should.equal no

        accepted = rejected = no
        window.confirm.returns no
        Dropzone.confirm &quot;test question 2&quot;, (-&gt; accepted = yes), (-&gt; rejected = yes)
        window.confirm.args[1][0].should.equal &quot;test question 2&quot;
        accepted.should.equal no
        rejected.should.equal yes

      it &quot;should not error if rejected is not provided&quot;, -&gt;
        accepted = rejected = no
        window.confirm.returns no
        Dropzone.confirm &quot;test question&quot;, (-&gt; accepted = yes)
        window.confirm.args[0][0].should.equal &quot;test question&quot;
        # Nothing should have changed since there is no rejected function.
        accepted.should.equal no
        rejected.should.equal no


  describe &quot;Dropzone.getElement() / getElements()&quot;, -&gt;
    tmpElements = [ ]

    beforeEach -&gt;
      tmpElements = [ ]
      tmpElements.push Dropzone.createElement &quot;&quot;&quot;&lt;div class=&quot;tmptest&quot;&gt;&lt;/div&gt;&quot;&quot;&quot;
      tmpElements.push Dropzone.createElement &quot;&quot;&quot;&lt;div id=&quot;tmptest1&quot; class=&quot;random&quot;&gt;&lt;/div&gt;&quot;&quot;&quot;
      tmpElements.push Dropzone.createElement &quot;&quot;&quot;&lt;div class=&quot;random div&quot;&gt;&lt;/div&gt;&quot;&quot;&quot;
      tmpElements.forEach (el) -&gt; document.body.appendChild el

    afterEach -&gt;
      tmpElements.forEach (el) -&gt; document.body.removeChild el

    describe &quot;.getElement()&quot;, -&gt;
      it &quot;should accept a string&quot;, -&gt;
        el = Dropzone.getElement &quot;.tmptest&quot;
        el.should.equal tmpElements[0]
        el = Dropzone.getElement &quot;#tmptest1&quot;
        el.should.equal tmpElements[1]
      it &quot;should accept a node&quot;, -&gt;
        el = Dropzone.getElement tmpElements[2]
        el.should.equal tmpElements[2]
      it &quot;should fail if invalid selector&quot;, -&gt;
        errorMessage = &quot;Invalid `clickable` option provided. Please provide a CSS selector or a plain HTML element.&quot;
        expect(-&gt; Dropzone.getElement &quot;lblasdlfsfl&quot;, &quot;clickable&quot;).to.throw errorMessage
        expect(-&gt; Dropzone.getElement { &quot;lblasdlfsfl&quot; }, &quot;clickable&quot;).to.throw errorMessage
        expect(-&gt; Dropzone.getElement [ &quot;lblasdlfsfl&quot; ], &quot;clickable&quot;).to.throw errorMessage

    describe &quot;.getElements()&quot;, -&gt;
      it &quot;should accept a list of strings&quot;, -&gt;
        els = Dropzone.getElements [ &quot;.tmptest&quot;, &quot;#tmptest1&quot; ]
        els.should.eql [ tmpElements[0], tmpElements[1] ]
      it &quot;should accept a list of nodes&quot;, -&gt;
        els = Dropzone.getElements [ tmpElements[0], tmpElements[2] ]
        els.should.eql [ tmpElements[0], tmpElements[2] ]
      it &quot;should accept a mixed list&quot;, -&gt;
        els = Dropzone.getElements [ &quot;#tmptest1&quot;, tmpElements[2] ]
        els.should.eql [ tmpElements[1], tmpElements[2] ]
      it &quot;should accept a string selector&quot;, -&gt;
        els = Dropzone.getElements &quot;.random&quot;
        els.should.eql [ tmpElements[1], tmpElements[2] ]
      it &quot;should accept a single node&quot;, -&gt;
        els = Dropzone.getElements tmpElements[1]
        els.should.eql [ tmpElements[1] ]
      it &quot;should fail if invalid selector&quot;, -&gt;
        errorMessage = &quot;Invalid `clickable` option provided. Please provide a CSS selector, a plain HTML element or a list of those.&quot;
        expect(-&gt; Dropzone.getElements &quot;lblasdlfsfl&quot;, &quot;clickable&quot;).to.throw errorMessage
        expect(-&gt; Dropzone.getElements [ &quot;lblasdlfsfl&quot; ], &quot;clickable&quot;).to.throw errorMessage

  describe &quot;constructor()&quot;, -&gt;

    dropzone = null

    afterEach -&gt; dropzone.destroy() if dropzone?

    it &quot;should throw an exception if the element is invalid&quot;, -&gt;
      expect(-&gt; dropzone = new Dropzone &quot;#invalid-element&quot;).to.throw &quot;Invalid dropzone element.&quot;

    it &quot;should throw an exception if assigned twice to the same element&quot;, -&gt;
      element = document.createElement &quot;div&quot;
      dropzone = new Dropzone element, url: &quot;url&quot;
      expect(-&gt; new Dropzone element, url: &quot;url&quot;).to.throw &quot;Dropzone already attached.&quot;

    it &quot;should throw an exception if both acceptedFiles and acceptedMimeTypes are specified&quot;, -&gt;
      element = document.createElement &quot;div&quot;
      expect(-&gt; dropzone = new Dropzone element, url: &quot;test&quot;, acceptedFiles: &quot;param&quot;, acceptedMimeTypes: &quot;types&quot;).to.throw &quot;You can't provide both 'acceptedFiles' and 'acceptedMimeTypes'. 'acceptedMimeTypes' is deprecated.&quot;

    it &quot;should set itself as element.dropzone&quot;, -&gt;
      element = document.createElement &quot;div&quot;
      dropzone = new Dropzone element, url: &quot;url&quot;
      element.dropzone.should.equal dropzone

    it &quot;should add itself to Dropzone.instances&quot;, -&gt;
      element = document.createElement &quot;div&quot;
      dropzone = new Dropzone element, url: &quot;url&quot;
      Dropzone.instances[Dropzone.instances.length - 1].should.equal dropzone

    it &quot;should use the action attribute not the element with the name action&quot;, -&gt;
      element = Dropzone.createElement &quot;&quot;&quot;&lt;form action=&quot;real-action&quot;&gt;&lt;input type=&quot;hidden&quot; name=&quot;action&quot; value=&quot;wrong-action&quot; /&gt;&lt;/form&gt;&quot;&quot;&quot;
      dropzone = new Dropzone element
      dropzone.options.url.should.equal &quot;real-action&quot;

    describe &quot;options&quot;, -&gt;
      element = null
      element2 = null
      beforeEach -&gt;
        element = document.createElement &quot;div&quot;
        element.id = &quot;test-element&quot;
        element2 = document.createElement &quot;div&quot;
        element2.id = &quot;test-element2&quot;
        Dropzone.options.testElement = url: &quot;/some/url&quot;, parallelUploads: 10
      afterEach -&gt; delete Dropzone.options.testElement

      it &quot;should take the options set in Dropzone.options&quot;, -&gt;
        dropzone = new Dropzone element
        dropzone.options.url.should.equal &quot;/some/url&quot;
        dropzone.options.parallelUploads.should.equal 10

      it &quot;should prefer passed options over Dropzone.options&quot;, -&gt;
        dropzone = new Dropzone element, url: &quot;/some/other/url&quot;
        dropzone.options.url.should.equal &quot;/some/other/url&quot;

      it &quot;should take the default options if nothing set in Dropzone.options&quot;, -&gt;
        dropzone = new Dropzone element2, url: &quot;/some/url&quot;
        dropzone.options.parallelUploads.should.equal 2

      it &quot;should call the fallback function if forceFallback == true&quot;, (done) -&gt;
        dropzone = new Dropzone element,
          url: &quot;/some/other/url&quot;
          forceFallback: on
          fallback: -&gt; done()

      it &quot;should set acceptedFiles if deprecated acceptedMimetypes option has been passed&quot;, -&gt;
        dropzone = new Dropzone element,
          url: &quot;/some/other/url&quot;
          acceptedMimeTypes: &quot;my/type&quot;
        dropzone.options.acceptedFiles.should.equal &quot;my/type&quot;

      describe &quot;options.clickable&quot;, -&gt;
        clickableElement = null
        dropzone = null
        beforeEach -&gt;
          clickableElement = document.createElement &quot;div&quot;
          clickableElement.className = &quot;some-clickable&quot;
          document.body.appendChild clickableElement
        afterEach -&gt;
          document.body.removeChild clickableElement
          dropzone.destroy if dropzone?

        it &quot;should use the default element if clickable == true&quot;, -&gt;
          dropzone = new Dropzone element, clickable: yes
          dropzone.clickableElements.should.eql [ dropzone.element ]
        it &quot;should lookup the element if clickable is a CSS selector&quot;, -&gt;
          dropzone = new Dropzone element, clickable: &quot;.some-clickable&quot;
          dropzone.clickableElements.should.eql [ clickableElement ]
        it &quot;should simply use the provided element&quot;, -&gt;
          dropzone = new Dropzone element, clickable: clickableElement
          dropzone.clickableElements.should.eql [ clickableElement ]
        it &quot;should accept multiple clickable elements&quot;, -&gt;
          dropzone = new Dropzone element, clickable: [ document.body, &quot;.some-clickable&quot; ]
          dropzone.clickableElements.should.eql [ document.body, clickableElement ]
        it &quot;should throw an exception if the element is invalid&quot;, -&gt;
          expect(-&gt; dropzone = new Dropzone element, clickable: &quot;.some-invalid-clickable&quot;).to.throw &quot;Invalid `clickable` option provided. Please provide a CSS selector, a plain HTML element or a list of those.&quot;




  describe &quot;init()&quot;, -&gt;
    describe &quot;clickable&quot;, -&gt;

      dropzones =
        &quot;using acceptedFiles&quot;: new Dropzone(Dropzone.createElement(&quot;&quot;&quot;&lt;form action=&quot;/&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;), { clickable: yes, acceptedFiles: &quot;audio/*,video/*&quot; })
        &quot;using acceptedMimeTypes&quot;: new Dropzone(Dropzone.createElement(&quot;&quot;&quot;&lt;form action=&quot;/&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;), { clickable: yes, acceptedMimeTypes: &quot;audio/*,video/*&quot; })

      it &quot;should not add an accept attribute if no acceptParameter&quot;, -&gt;
        dropzone = new Dropzone (Dropzone.createElement &quot;&quot;&quot;&lt;form action=&quot;/&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;), clickable: yes, acceptParameter: null, acceptedMimeTypes: null
        dropzone.hiddenFileInput.hasAttribute(&quot;accept&quot;).should.be.false


      for name, dropzone of dropzones
        describe name, -&gt;
          do (dropzone) -&gt;
            it &quot;should create a hidden file input if clickable&quot;, -&gt;
              dropzone.hiddenFileInput.should.be.ok
              dropzone.hiddenFileInput.tagName.should.equal &quot;INPUT&quot;

            it &quot;should use the acceptParameter&quot;, -&gt;
              dropzone.hiddenFileInput.getAttribute(&quot;accept&quot;).should.equal &quot;audio/*,video/*&quot;

            it &quot;should create a new input element when something is selected to reset the input field&quot;, -&gt;
              for i in [0..3]
                hiddenFileInput = dropzone.hiddenFileInput
                event = document.createEvent &quot;HTMLEvents&quot;
                event.initEvent &quot;change&quot;, true, true
                hiddenFileInput.dispatchEvent event
                dropzone.hiddenFileInput.should.not.equal hiddenFileInput
                Dropzone.elementInside(hiddenFileInput, document).should.not.be.ok

    it &quot;should create a .dz-message element&quot;, -&gt;
      element = Dropzone.createElement &quot;&quot;&quot;&lt;form class=&quot;dropzone&quot; action=&quot;/&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;
      dropzone = new Dropzone element, clickable: yes, acceptParameter: null, acceptedMimeTypes: null
      element.querySelector(&quot;.dz-message&quot;).should.be.instanceof Element

    it &quot;should not create a .dz-message element if there already is one&quot;, -&gt;
      element = Dropzone.createElement &quot;&quot;&quot;&lt;form class=&quot;dropzone&quot; action=&quot;/&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;
      msg = Dropzone.createElement &quot;&quot;&quot;&lt;div class=&quot;dz-message&quot;&gt;TEST&lt;/div&gt;&quot;&quot;&quot;
      element.appendChild msg

      dropzone = new Dropzone element, clickable: yes, acceptParameter: null, acceptedMimeTypes: null
      element.querySelector(&quot;.dz-message&quot;).should.equal msg

      element.querySelectorAll(&quot;.dz-message&quot;).length.should.equal 1



  describe &quot;options&quot;, -&gt;

    element = null
    dropzone = null

    beforeEach -&gt;
      element = Dropzone.createElement &quot;&quot;&quot;&lt;div&gt;&lt;/div&gt;&quot;&quot;&quot;
      dropzone = new Dropzone element, maxFilesize: 4, url: &quot;url&quot;, acceptedMimeTypes: &quot;audio/*,image/png&quot;, maxFiles: 3

    describe &quot;file specific&quot;, -&gt;
      file = null
      beforeEach -&gt;
        file =
          name: &quot;test name&quot;
          size: 2 * 1024 * 1024
          width: 200
          height: 100
        dropzone.options.addedfile.call dropzone, file

      describe &quot;.addedFile()&quot;, -&gt;
        it &quot;should properly create the previewElement&quot;, -&gt;
          file.previewElement.should.be.instanceof Element

          file.previewElement.querySelector(&quot;[data-dz-name]&quot;).innerHTML.should.eql &quot;test name&quot;
          file.previewElement.querySelector(&quot;[data-dz-size]&quot;).innerHTML.should.eql &quot;&lt;strong&gt;2.1&lt;/strong&gt; MB&quot;

      describe &quot;.error()&quot;, -&gt;
        it &quot;should properly insert the error&quot;, -&gt;
          dropzone.options.error.call dropzone, file, &quot;test message&quot;

          file.previewElement.querySelector(&quot;[data-dz-errormessage]&quot;).innerHTML.should.eql &quot;test message&quot;

        it &quot;should properly insert the error when provided with an object containing the error&quot;, -&gt;
          dropzone.options.error.call dropzone, file, error: &quot;test message&quot;

          file.previewElement.querySelector(&quot;[data-dz-errormessage]&quot;).innerHTML.should.eql &quot;test message&quot;

      describe &quot;.thumbnail()&quot;, -&gt;
        it &quot;should properly insert the error&quot;, -&gt;
          transparentGif = &quot;data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==&quot;
          dropzone.options.thumbnail.call dropzone, file, transparentGif
          thumbnail = file.previewElement.querySelector(&quot;[data-dz-thumbnail]&quot;)
          thumbnail.src.should.eql transparentGif
          thumbnail.alt.should.eql &quot;test name&quot;

      describe &quot;.uploadprogress()&quot;, -&gt;
        it &quot;should properly set the width&quot;, -&gt;
          dropzone.options.uploadprogress.call dropzone, file, 0
          file.previewElement.querySelector(&quot;[data-dz-uploadprogress]&quot;).style.width.should.eql &quot;0%&quot;
          dropzone.options.uploadprogress.call dropzone, file, 80
          file.previewElement.querySelector(&quot;[data-dz-uploadprogress]&quot;).style.width.should.eql &quot;80%&quot;
          dropzone.options.uploadprogress.call dropzone, file, 90
          file.previewElement.querySelector(&quot;[data-dz-uploadprogress]&quot;).style.width.should.eql &quot;90%&quot;
          dropzone.options.uploadprogress.call dropzone, file, 100
          file.previewElement.querySelector(&quot;[data-dz-uploadprogress]&quot;).style.width.should.eql &quot;100%&quot;

      describe &quot;.resize()&quot;, -&gt;

        describe &quot;with default thumbnail settings&quot;, -&gt;
          it &quot;should properly return target dimensions&quot;, -&gt;

            info = dropzone.options.resize.call dropzone, file

            info.optWidth.should.eql 120
            info.optHeight.should.eql 120

        describe &quot;with null thumbnail settings&quot;, -&gt;
          it &quot;should properly return target dimensions&quot;, -&gt;
            testSettings = [
              [null, null],
              [null, 150],
              [150, null]
            ]

            for setting, i in testSettings
              dropzone.options.thumbnailWidth = setting[0]
              dropzone.options.thumbnailHeight = setting[1]

              info = dropzone.options.resize.call dropzone, file

              if i is 0
                info.optWidth.should.eql 200
                info.optHeight.should.eql 100

              if i is 1
                info.optWidth.should.eql 300
                info.optHeight.should.eql 150

              if i is 2
                info.optWidth.should.eql 150
                info.optHeight.should.eql 75

  describe &quot;instance&quot;, -&gt;

    element = null
    dropzone = null
    requests = null
    beforeEach -&gt;
      requests = [ ]
      xhr.onCreate = (xhr) -&gt; requests.push xhr

      element = Dropzone.createElement &quot;&quot;&quot;&lt;div&gt;&lt;/div&gt;&quot;&quot;&quot;
      document.body.appendChild element
      dropzone = new Dropzone element, maxFilesize: 4, maxFiles: 100, url: &quot;url&quot;, acceptedMimeTypes: &quot;audio/*,image/png&quot;, uploadprogress: -&gt;
    afterEach -&gt;
      document.body.removeChild element
      dropzone.destroy()
      xhr.restore()

    describe &quot;.accept()&quot;, -&gt;

      it &quot;should pass if the filesize is OK&quot;, -&gt;
        dropzone.accept { size: 2 * 1024 * 1024, type: &quot;audio/mp3&quot; }, (err) -&gt; expect(err).to.be.undefined

      it &quot;shouldn't pass if the filesize is too big&quot;, -&gt;
        dropzone.accept { size: 10 * 1024 * 1024, type: &quot;audio/mp3&quot; }, (err) -&gt; err.should.eql &quot;File is too big (10MiB). Max filesize: 4MiB.&quot;

      it &quot;should properly accept files which mime types are listed in acceptedFiles&quot;, -&gt;

        dropzone.accept { type: &quot;audio/mp3&quot; }, (err) -&gt; expect(err).to.be.undefined
        dropzone.accept { type: &quot;image/png&quot; }, (err) -&gt; expect(err).to.be.undefined
        dropzone.accept { type: &quot;audio/wav&quot; }, (err) -&gt; expect(err).to.be.undefined

      it &quot;should properly reject files when the mime type isn't listed in acceptedFiles&quot;, -&gt;
        dropzone.accept { type: &quot;image/jpeg&quot; }, (err) -&gt; err.should.eql &quot;You can't upload files of this type.&quot;

      it &quot;should fail if maxFiles has been exceeded and call the event maxfilesexceeded&quot;, -&gt;
        sinon.stub dropzone, &quot;getAcceptedFiles&quot;
        file = { type: &quot;audio/mp3&quot; }

        dropzone.getAcceptedFiles.returns { length: 99 }

        dropzone.options.dictMaxFilesExceeded = &quot;You can only upload {{maxFiles}} files.&quot;

        called = no
        dropzone.on &quot;maxfilesexceeded&quot;, (lfile) -&gt;
          lfile.should.equal file
          called = yes

        dropzone.accept file, (err) -&gt; expect(err).to.be.undefined
        called.should.not.be.ok

        dropzone.getAcceptedFiles.returns { length: 100 }
        dropzone.accept file, (err) -&gt; expect(err).to.equal &quot;You can only upload 100 files.&quot;
        called.should.be.ok

        dropzone.getAcceptedFiles.restore()

      it &quot;should properly handle if maxFiles is 0&quot;, -&gt;
        file = { type: &quot;audio/mp3&quot; }

        dropzone.options.maxFiles = 0

        called = no
        dropzone.on &quot;maxfilesexceeded&quot;, (lfile) -&gt;
          lfile.should.equal file
          called = yes

        dropzone.accept file, (err) -&gt; expect(err).to.equal &quot;You can not upload any more files.&quot;
        called.should.be.ok



    describe &quot;.removeFile()&quot;, -&gt;
      it &quot;should abort uploading if file is currently being uploaded&quot;, (done) -&gt;
        mockFile = getMockFile()
        dropzone.uploadFile = (file) -&gt;
        dropzone.accept = (file, done) -&gt; done()

        sinon.stub dropzone, &quot;cancelUpload&quot;

        dropzone.addFile mockFile
        setTimeout -&gt;
          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
          done()
        , 10

    describe &quot;.cancelUpload()&quot;, -&gt;
      it &quot;should properly cancel upload if file currently uploading&quot;, (done) -&gt;
        mockFile = getMockFile()

        dropzone.accept = (file, done) -&gt; done()

        dropzone.addFile mockFile

        setTimeout -&gt;
          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
          done()
        , 10

      it &quot;should properly cancel the upload if file is not yet uploading&quot;, -&gt;
        mockFile = getMockFile()

        dropzone.accept = (file, done) -&gt; done()

        # Making sure the file stays in the queue.
        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
        dropzone.getUploadingFiles().length.should.equal 0

      it &quot;should call processQueue()&quot;, (done) -&gt;
        mockFile = getMockFile()

        dropzone.accept = (file, done) -&gt; done()

        # Making sure the file stays in the queue.
        dropzone.options.parallelUploads = 0

        sinon.spy dropzone, &quot;processQueue&quot;

        dropzone.addFile mockFile
        setTimeout -&gt;
          dropzone.processQueue.callCount.should.equal 1

          dropzone.cancelUpload mockFile

          dropzone.processQueue.callCount.should.equal 2
          done()
        , 10

      it &quot;should properly cancel all files with the same XHR if uploadMultiple is true&quot;, (done) -&gt;
        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()

        dropzone.accept = (file, done) -&gt; done()

        # Making sure the file stays in the queue.
        dropzone.options.uploadMultiple = yes
        dropzone.options.parallelUploads = 3

        sinon.spy dropzone, &quot;processFiles&quot;

        dropzone.addFile mock1
        dropzone.addFile mock2
        dropzone.addFile mock3

        setTimeout -&gt;
          dropzone.processFiles.callCount.should.equal 1

          sinon.spy mock1.xhr, &quot;abort&quot;

          dropzone.cancelUpload mock1

          expect(mock1.xhr == mock2.xhr == mock3.xhr).to.be.ok

          mock1.status.should.equal Dropzone.CANCELED
          mock2.status.should.equal Dropzone.CANCELED
          mock3.status.should.equal Dropzone.CANCELED

          # The XHR should only be aborted once!
          mock1.xhr.abort.callCount.should.equal 1

          done()
        , 10



    describe &quot;.disable()&quot;, -&gt;
      it &quot;should properly cancel all pending uploads&quot;, (done) -&gt;
          dropzone.accept = (file, done) -&gt; done()

          dropzone.options.parallelUploads = 1

          dropzone.addFile getMockFile()
          dropzone.addFile getMockFile()

          setTimeout -&gt;

            dropzone.getUploadingFiles().length.should.equal 1
            dropzone.getQueuedFiles().length.should.equal 1
            dropzone.files.length.should.equal 2

            sinon.spy requests[0], &quot;abort&quot;

            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
            done()
          , 10

    describe &quot;.destroy()&quot;, -&gt;
      it &quot;should properly cancel all pending uploads and remove all file references&quot;, (done) -&gt;
        dropzone.accept = (file, done) -&gt; done()

        dropzone.options.parallelUploads = 1

        dropzone.addFile getMockFile()
        dropzone.addFile getMockFile()


        setTimeout -&gt;
          dropzone.getUploadingFiles().length.should.equal 1
          dropzone.getQueuedFiles().length.should.equal 1
          dropzone.files.length.should.equal 2

          sinon.spy dropzone, &quot;disable&quot;

          dropzone.destroy()

          dropzone.disable.callCount.should.equal 1
          element.should.not.have.property &quot;dropzone&quot;
          done()
        , 10

      it &quot;should be able to create instance of dropzone on the same element after destroy&quot;, -&gt;
        dropzone.destroy()
        ( -&gt; new Dropzone element, maxFilesize: 4, url: &quot;url&quot;, acceptedMimeTypes: &quot;audio/*,image/png&quot;, uploadprogress: -&gt; ).should.not.throw( Error )

      it &quot;should remove itself from Dropzone.instances&quot;, -&gt;
        (Dropzone.instances.indexOf(dropzone) != -1).should.be.ok
        dropzone.destroy()
        (Dropzone.instances.indexOf(dropzone) == -1).should.be.ok



    describe &quot;.filesize()&quot;, -&gt;

      it &quot;should handle files with 0 size properly&quot;, -&gt;
        dropzone.filesize(0).should.eql &quot;&lt;strong&gt;0&lt;/strong&gt; b&quot;

      it &quot;should convert to KiloBytes, etc..&quot;, -&gt;

        dropzone.options.filesizeBase.should.eql 1000 # Just making sure the default config is correct

        dropzone.filesize(2 * 1000 * 1000).should.eql &quot;&lt;strong&gt;2&lt;/strong&gt; MB&quot;
        dropzone.filesize(2 * 1024 * 1024).should.eql &quot;&lt;strong&gt;2.1&lt;/strong&gt; MB&quot;

        dropzone.filesize(2 * 1000 * 1000 * 1000).should.eql &quot;&lt;strong&gt;2&lt;/strong&gt; GB&quot;
        dropzone.filesize(2 * 1024 * 1024 * 1024).should.eql &quot;&lt;strong&gt;2.1&lt;/strong&gt; GB&quot;

        dropzone.filesize(2.5111 * 1000 * 1000 * 1000).should.eql &quot;&lt;strong&gt;2.5&lt;/strong&gt; GB&quot;
        dropzone.filesize(1.1 * 1000).should.eql &quot;&lt;strong&gt;1.1&lt;/strong&gt; KB&quot;
        dropzone.filesize(999 * 1000).should.eql &quot;&lt;strong&gt;1&lt;/strong&gt; MB&quot;

      it &quot;should convert to KibiBytes, etc.. when the filesizeBase is changed to 1024&quot;, -&gt;

        dropzone.options.filesizeBase = 1024

        dropzone.filesize(2 * 1024 * 1024).should.eql &quot;&lt;strong&gt;2&lt;/strong&gt; MB&quot;
        dropzone.filesize(2 * 1000 * 1000).should.eql &quot;&lt;strong&gt;1.9&lt;/strong&gt; MB&quot;


    describe &quot;._updateMaxFilesReachedClass()&quot;, -&gt;
      it &quot;should properly add the dz-max-files-reached class&quot;, -&gt;
        dropzone.getAcceptedFiles = -&gt; length: 10
        dropzone.options.maxFiles = 10
        dropzone.element.classList.contains(&quot;dz-max-files-reached&quot;).should.not.be.ok
        dropzone._updateMaxFilesReachedClass()
        dropzone.element.classList.contains(&quot;dz-max-files-reached&quot;).should.be.ok
      it &quot;should fire the 'maxfilesreached' event when appropriate&quot;, -&gt;
        spy = sinon.spy()
        dropzone.on &quot;maxfilesreached&quot;, -&gt; spy()
        dropzone.getAcceptedFiles = -&gt; length: 9
        dropzone.options.maxFiles = 10
        dropzone._updateMaxFilesReachedClass()
        spy.should.not.have.been.called
        dropzone.getAcceptedFiles = -&gt; length: 10
        dropzone._updateMaxFilesReachedClass()
        spy.should.have.been.called
        dropzone.getAcceptedFiles = -&gt; length: 11
        dropzone._updateMaxFilesReachedClass()
        spy.should.have.been.calledOnce #ie, it has not been called again

      it &quot;should properly remove the dz-max-files-reached class&quot;, -&gt;
        dropzone.getAcceptedFiles = -&gt; length: 10
        dropzone.options.maxFiles = 10
        dropzone.element.classList.contains(&quot;dz-max-files-reached&quot;).should.not.be.ok
        dropzone._updateMaxFilesReachedClass()
        dropzone.element.classList.contains(&quot;dz-max-files-reached&quot;).should.be.ok
        dropzone.getAcceptedFiles = -&gt; length: 9
        dropzone._updateMaxFilesReachedClass()
        dropzone.element.classList.contains(&quot;dz-max-files-reached&quot;).should.not.be.ok

    describe &quot;events&quot;, -&gt;

      describe &quot;progress updates&quot;, -&gt;

        it &quot;should properly emit a totaluploadprogress event&quot;, (done) -&gt;
          dropzone.files = [
            {
              size: 1990
              accepted: true
              status: Dropzone.UPLOADING
              upload:
                progress: 20
                total: 2000 # The bytes to upload are higher than the file size
                bytesSent: 400
            }
            {
              size: 1990
              accepted: true
              status: Dropzone.UPLOADING
              upload:
                progress: 10
                total: 2000 # The bytes to upload are higher than the file size
                bytesSent: 200
            }
          ]

          _called = 0

          dropzone.on &quot;totaluploadprogress&quot;, (progress) -&gt;
            progress.should.equal totalProgressExpectation
            done() if ++_called == 3

          totalProgressExpectation = 15
          dropzone.emit &quot;uploadprogress&quot;, { }

          totalProgressExpectation = 97.5
          dropzone.files[0].upload.bytesSent = 2000
          dropzone.files[1].upload.bytesSent = 1900
          # It shouldn't matter that progress is not properly updated since the total size
          # should be calculated from the bytes
          dropzone.emit &quot;uploadprogress&quot;, { }

          totalProgressExpectation = 100
          dropzone.files[0].upload.bytesSent = 2000
          dropzone.files[1].upload.bytesSent = 2000
          # It shouldn't matter that progress is not properly updated since the total size
          # should be calculated from the bytes
          dropzone.emit &quot;uploadprogress&quot;, { }

          # Just so the afterEach hook doesn't try to cancel them.
          dropzone.files[0].status = Dropzone.CANCELED
          dropzone.files[1].status = Dropzone.CANCELED


  describe &quot;helper function&quot;, -&gt;
    element = null
    dropzone = null
    beforeEach -&gt;
      element = Dropzone.createElement &quot;&quot;&quot;&lt;div&gt;&lt;/div&gt;&quot;&quot;&quot;
      dropzone = new Dropzone element, url: &quot;url&quot;

    describe &quot;getExistingFallback()&quot;, -&gt;
      it &quot;should return undefined if no fallback&quot;, -&gt;
        expect(dropzone.getExistingFallback()).to.equal undefined

      it &quot;should only return the fallback element if it contains exactly fallback&quot;, -&gt;
        element.appendChild Dropzone.createElement &quot;&quot;&quot;&lt;form class=&quot;fallbacks&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;
        element.appendChild Dropzone.createElement &quot;&quot;&quot;&lt;form class=&quot;sfallback&quot;&gt;&lt;/form&gt;&quot;&quot;&quot;
        expect(dropzone.getExistingFallback()).to.equal undefined

      it &quot;should return divs as fallback&quot;, -&gt;
        fallback = Dropzone.createElement &quot;&quot;&quot;&lt;form class=&quot; abc fallback test &quot;&gt;&lt;/form&gt;&quot;&quot;&quot;
        element.appendChild fallback
        fallback.should.equal dropzone.getExistingFallback()
      it &quot;should return forms as fallback&quot;, -&gt;
        fallback = Dropzone.createElement &quot;&quot;&quot;&lt;div class=&quot; abc fallback test &quot;&gt;&lt;/div&gt;&quot;&quot;&quot;
        element.appendChild fallback
        fallback.should.equal dropzone.getExistingFallback()

    describe &quot;getFallbackForm()&quot;, -&gt;
      it &quot;should use the paramName without [0] if uploadMultiple is false&quot;, -&gt;
        dropzone.options.uploadMultiple = false
        dropzone.options.paramName = &quot;myFile&quot;
        fallback = dropzone.getFallbackForm()
        fileInput = fallback.querySelector &quot;input[type=file]&quot;
        fileInput.name.should.equal &quot;myFile&quot;
      it &quot;should properly add [0] to the file name if uploadMultiple is true&quot;, -&gt;
        dropzone.options.uploadMultiple = yes
        dropzone.options.paramName = &quot;myFile&quot;
        fallback = dropzone.getFallbackForm()
        fileInput = fallback.querySelector &quot;input[type=file]&quot;
        fileInput.name.should.equal &quot;myFile[0]&quot;


    describe &quot;getAcceptedFiles() / getRejectedFiles()&quot;, -&gt;
      mock1 = mock2 = mock3 = mock4 = null
      beforeEach -&gt;
        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()
        mock4 = getMockFile()
        dropzone.options.accept = (file, done) -&gt;
          if file in [ mock1, mock3 ]
            done()
          else
            done &quot;error&quot;
        dropzone.addFile mock1
        dropzone.addFile mock2
        dropzone.addFile mock3
        dropzone.addFile mock4

      it &quot;getAcceptedFiles() should only return accepted files&quot;, -&gt;
        dropzone.getAcceptedFiles().should.eql [ mock1, mock3 ]
      it &quot;getRejectedFiles() should only return rejected files&quot;, -&gt;
        dropzone.getRejectedFiles().should.eql [ mock2, mock4 ]

    describe &quot;getQueuedFiles()&quot;, -&gt;
      it &quot;should return all files with the status Dropzone.QUEUED&quot;, -&gt;
        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()
        mock4 = getMockFile()

        dropzone.options.accept = (file, done) -&gt; 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
        mock4.status.should.equal Dropzone.ADDED


    describe &quot;getUploadingFiles()&quot;, -&gt;
      it &quot;should return all files with the status Dropzone.UPLOADING&quot;, (done) -&gt;
        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()
        mock4 = getMockFile()

        dropzone.options.accept = (file, _done) -&gt; file.done = _done
        dropzone.uploadFile = -&gt;

        dropzone.addFile mock1
        dropzone.addFile mock2
        dropzone.addFile mock3
        dropzone.addFile mock4

        dropzone.getUploadingFiles().should.eql [ ]

        mock1.done()
        mock3.done()

        setTimeout (-&gt;
          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
          done()
        ), 10


    describe &quot;getActiveFiles()&quot;, -&gt;
      it &quot;should return all files with the status Dropzone.UPLOADING or Dropzone.QUEUED&quot;, (done) -&gt;
        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()
        mock4 = getMockFile()

        dropzone.options.accept = (file, _done) -&gt; file.done = _done
        dropzone.uploadFile = -&gt;
        dropzone.options.parallelUploads = 2

        dropzone.addFile mock1
        dropzone.addFile mock2
        dropzone.addFile mock3
        dropzone.addFile mock4

        dropzone.getActiveFiles().should.eql [ ]

        mock1.done()
        mock3.done()
        mock4.done()

        setTimeout (-&gt;
          dropzone.getActiveFiles().should.eql [ mock1, mock3, mock4 ]
          mock1.status.should.equal Dropzone.UPLOADING
          mock3.status.should.equal Dropzone.UPLOADING
          mock2.status.should.equal Dropzone.ADDED
          mock4.status.should.equal Dropzone.QUEUED
          done()
        ), 10


    describe &quot;getFilesWithStatus()&quot;, -&gt;
      it &quot;should return all files with provided status&quot;, -&gt;
        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()
        mock4 = getMockFile()

        dropzone.options.accept = (file, _done) -&gt; file.done = _done
        dropzone.uploadFile = -&gt;

        dropzone.addFile mock1
        dropzone.addFile mock2
        dropzone.addFile mock3
        dropzone.addFile mock4

        dropzone.getFilesWithStatus(Dropzone.ADDED).should.eql [ mock1, mock2, mock3, mock4 ]

        mock1.status = Dropzone.UPLOADING
        mock3.status = Dropzone.QUEUED
        mock4.status = Dropzone.QUEUED

        dropzone.getFilesWithStatus(Dropzone.ADDED).should.eql [ mock2 ]
        dropzone.getFilesWithStatus(Dropzone.UPLOADING).should.eql [ mock1 ]
        dropzone.getFilesWithStatus(Dropzone.QUEUED).should.eql [ mock3, mock4 ]
        



  describe &quot;file handling&quot;, -&gt;
    mockFile = null
    dropzone = null


    beforeEach -&gt;
      mockFile = getMockFile()

      element = Dropzone.createElement &quot;&quot;&quot;&lt;div&gt;&lt;/div&gt;&quot;&quot;&quot;
      dropzone = new Dropzone element, url: &quot;/the/url&quot;

    afterEach -&gt;
      dropzone.destroy()


    describe &quot;addFile()&quot;, -&gt;
      it &quot;should properly set the status of the file&quot;, -&gt;
        doneFunction = null

        dropzone.accept = (file, done) -&gt; doneFunction = done
        dropzone.processFile = -&gt;
        dropzone.uploadFile = -&gt;

        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(&quot;error&quot;)
        mockFile.status.should.eql Dropzone.ERROR

      it &quot;should properly set the status of the file if autoProcessQueue is false and not call processQueue&quot;, (done) -&gt;
        doneFunction = null
        dropzone.options.autoProcessQueue = false
        dropzone.accept = (file, done) -&gt; doneFunction = done
        dropzone.processFile = -&gt;
        dropzone.uploadFile = -&gt;

        dropzone.addFile mockFile
        sinon.stub dropzone, &quot;processQueue&quot;

        mockFile.status.should.eql Dropzone.ADDED
        doneFunction()
        mockFile.status.should.eql Dropzone.QUEUED
        dropzone.processQueue.callCount.should.equal 0
        setTimeout (-&gt;
          dropzone.processQueue.callCount.should.equal 0
          done()
        ), 10

      it &quot;should not add the file to the queue if autoQueue is false&quot;, -&gt;
        doneFunction = null
        dropzone.options.autoQueue = false
        dropzone.accept = (file, done) -&gt; doneFunction = done
        dropzone.processFile = -&gt;
        dropzone.uploadFile = -&gt;

        dropzone.addFile mockFile

        mockFile.status.should.eql Dropzone.ADDED
        doneFunction()
        mockFile.status.should.eql Dropzone.ADDED

      it &quot;should create a remove link if configured to do so&quot;, -&gt;
        dropzone.options.addRemoveLinks = true
        dropzone.processFile = -&gt;
        dropzone.uploadFile = -&gt;

        sinon.stub dropzone, &quot;processQueue&quot;
        dropzone.addFile mockFile

        dropzone.files[0].previewElement.querySelector(&quot;a[data-dz-remove].dz-remove&quot;).should.be.ok


      it &quot;should attach an event handler to data-dz-remove links&quot;, -&gt;
        dropzone.options.previewTemplate = &quot;&quot;&quot;
                                            &lt;div class=&quot;dz-preview dz-file-preview&quot;&gt;
                                              &lt;div class=&quot;dz-details&quot;&gt;
                                                &lt;div class=&quot;dz-filename&quot;&gt;&lt;span data-dz-name&gt;&lt;/span&gt;&lt;/div&gt;
                                                &lt;div class=&quot;dz-size&quot; data-dz-size&gt;&lt;/div&gt;
                                                &lt;img data-dz-thumbnail /&gt;
                                              &lt;/div&gt;
                                              &lt;div class=&quot;dz-progress&quot;&gt;&lt;span class=&quot;dz-upload&quot; data-dz-uploadprogress&gt;&lt;/span&gt;&lt;/div&gt;
                                              &lt;div class=&quot;dz-success-mark&quot;&gt;&lt;span&gt;✔&lt;/span&gt;&lt;/div&gt;
                                              &lt;div class=&quot;dz-error-mark&quot;&gt;&lt;span&gt;✘&lt;/span&gt;&lt;/div&gt;
                                              &lt;div class=&quot;dz-error-message&quot;&gt;&lt;span data-dz-errormessage&gt;&lt;/span&gt;&lt;/div&gt;
                                              &lt;a class=&quot;link1&quot; data-dz-remove&gt;&lt;/a&gt;
                                              &lt;a class=&quot;link2&quot; data-dz-remove&gt;&lt;/a&gt;
                                            &lt;/div&gt;
                                            &quot;&quot;&quot;

        sinon.stub dropzone, &quot;processQueue&quot;

        dropzone.addFile mockFile

        file = dropzone.files[0]
        removeLink1 = file.previewElement.querySelector(&quot;a[data-dz-remove].link1&quot;)
        removeLink2 = file.previewElement.querySelector(&quot;a[data-dz-remove].link2&quot;)

        sinon.stub dropzone, &quot;removeFile&quot;

        event = document.createEvent &quot;HTMLEvents&quot;
        event.initEvent &quot;click&quot;, true, true
        removeLink1.dispatchEvent event

        dropzone.removeFile.callCount.should.eql 1

        event = document.createEvent &quot;HTMLEvents&quot;
        event.initEvent &quot;click&quot;, true, true
        removeLink2.dispatchEvent event

        dropzone.removeFile.callCount.should.eql 2



      describe &quot;thumbnails&quot;, -&gt;
        it &quot;should properly queue the thumbnail creation&quot;, (done) -&gt;
          doneFunction = null

          dropzone.accept = (file, done) -&gt; doneFunction = done
          dropzone.processFile = -&gt;
          dropzone.uploadFile = -&gt;

          mock1 = getMockFile()
          mock2 = getMockFile()
          mock3 = getMockFile()
          mock1.type = &quot;image/jpg&quot;
          mock2.type = &quot;image/jpg&quot;
          mock3.type = &quot;image/jpg&quot;

          dropzone.on &quot;thumbnail&quot;, -&gt;
            console.log &quot;HII&quot;

          ct_file = ct_callback = null
          dropzone.createThumbnail = (file, callback) -&gt;
            ct_file = file
            ct_callback = callback

          sinon.spy dropzone, &quot;createThumbnail&quot;
          
          dropzone.addFile mock1
          dropzone.addFile mock2
          dropzone.addFile mock3

          dropzone.files.length.should.eql 3
          setTimeout (-&gt;
            dropzone.createThumbnail.callCount.should.eql 1
            mock1.should.equal ct_file
            ct_callback()
            dropzone.createThumbnail.callCount.should.eql 2
            mock2.should.equal ct_file
            ct_callback()
            dropzone.createThumbnail.callCount.should.eql 3
            mock3.should.equal ct_file

            done()
          ), 10
          

          # dropzone.addFile mock1

        describe &quot;when file is SVG&quot;, -&gt;
          it &quot;should use the SVG image itself&quot;, (done) -&gt;

            createBlob = (data, type) -&gt;
              try
                new Blob([data], type: type)
              catch e
                BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder ||
                    window.MozBlobBuilder || window.MSBlobBuilder
                builder = new BlobBuilder()
                builder.append(data.buffer || data)
                builder.getBlob(type)

            blob = createBlob('foo', 'image/svg+xml')

            dropzone.on &quot;thumbnail&quot;, (file, dataURI) -&gt;
              file.should.equal blob
              fileReader = new FileReader
              fileReader.onload = -&gt;
                fileReader.result.should.equal dataURI
                done()
              fileReader.readAsDataURL(file)

            dropzone.createThumbnail(blob)

    describe &quot;enqueueFile()&quot;, -&gt;
      it &quot;should be wrapped by enqueueFiles()&quot;, -&gt;
        sinon.stub dropzone, &quot;enqueueFile&quot;

        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
        dropzone.enqueueFile.args[2][0].should.equal mock3

      it &quot;should fail if the file has already been processed&quot;, -&gt;
        mockFile.status = Dropzone.ERROR
        expect((-&gt; dropzone.enqueueFile(mockFile))).to.throw &quot;This file can't be queued because it has already been processed or was rejected.&quot;
        mockFile.status = Dropzone.COMPLETE
        expect((-&gt; dropzone.enqueueFile(mockFile))).to.throw &quot;This file can't be queued because it has already been processed or was rejected.&quot;
        mockFile.status = Dropzone.UPLOADING
        expect((-&gt; dropzone.enqueueFile(mockFile))).to.throw &quot;This file can't be queued because it has already been processed or was rejected.&quot;

      it &quot;should set the status to QUEUED and call processQueue asynchronously if everything's ok&quot;, (done) -&gt;
        mockFile.status = Dropzone.ADDED
        sinon.stub dropzone, &quot;processQueue&quot;
        dropzone.processQueue.callCount.should.equal 0
        dropzone.enqueueFile mockFile
        mockFile.status.should.equal Dropzone.QUEUED
        dropzone.processQueue.callCount.should.equal 0
        setTimeout -&gt;
          dropzone.processQueue.callCount.should.equal 1
          done()
        , 10

    describe &quot;uploadFiles()&quot;, -&gt;
      requests = null



      beforeEach -&gt;
        requests = [ ]

        xhr.onCreate = (xhr) -&gt; requests.push xhr

      afterEach -&gt;
        xhr.restore()

      # Removed this test because multiple filenames can be transmitted now
      # it &quot;should properly urlencode the filename for the headers&quot;

      it &quot;should be wrapped by uploadFile()&quot;, -&gt;
        sinon.stub dropzone, &quot;uploadFiles&quot;

        dropzone.uploadFile mockFile

        dropzone.uploadFiles.callCount.should.equal 1
        dropzone.uploadFiles.calledWith([ mockFile ]).should.be.ok

      it &quot;should use url options if strings&quot;, (done) -&gt;

        dropzone.addFile mockFile

        setTimeout -&gt;
          expect(requests.length).to.equal 1
          expect(requests[0].url).to.equal dropzone.options.url
          expect(requests[0].method).to.equal dropzone.options.method
          done()
        , 10

      it &quot;should call url options if functions&quot;, (done) -&gt;
        method = &quot;PUT&quot;
        url = &quot;/custom/upload/url&quot;

        dropzone.options.method = sinon.stub().returns method
        dropzone.options.url = sinon.stub().returns url

        dropzone.addFile mockFile

        setTimeout -&gt;
          dropzone.options.method.callCount.should.equal 1
          dropzone.options.url.callCount.should.equal 1
          sinon.assert.calledWith dropzone.options.method, [mockFile]
          sinon.assert.calledWith dropzone.options.url, [mockFile]
          expect(requests.length).to.equal 1
          expect(requests[0].url).to.equal url
          expect(requests[0].method).to.equal method
          done()
        , 10

      it &quot;should ignore the onreadystate callback if readyState != 4&quot;, (done) -&gt;
        dropzone.addFile mockFile

        setTimeout -&gt;

          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
          done()
        , 10
      

      it &quot;should emit error and errormultiple when response was not OK&quot;, (done) -&gt;
        dropzone.options.uploadMultiple = yes

        error = no
        errormultiple = no
        complete = no
        completemultiple = no
        dropzone.on &quot;error&quot;, -&gt; error = yes
        dropzone.on &quot;errormultiple&quot;, -&gt; errormultiple = yes
        dropzone.on &quot;complete&quot;, -&gt; complete = yes
        dropzone.on &quot;completemultiple&quot;, -&gt; completemultiple = yes

        dropzone.addFile mockFile

        setTimeout -&gt;

          mockFile.status.should.eql Dropzone.UPLOADING

          requests[0].status = 400
          requests[0].readyState = 4
          requests[0].onload()

          expect(yes == error == errormultiple == complete == completemultiple).to.be.ok

          done()
        , 10

      it &quot;should include hidden files in the form and unchecked checkboxes and radiobuttons should be excluded&quot;, (done) -&gt;
        element = Dropzone.createElement &quot;&quot;&quot;&lt;form action=&quot;/the/url&quot;&gt;
                                              &lt;input type=&quot;hidden&quot; name=&quot;test&quot; value=&quot;hidden&quot; /&gt;
                                              &lt;input type=&quot;checkbox&quot; name=&quot;unchecked&quot; value=&quot;1&quot; /&gt;
                                              &lt;input type=&quot;checkbox&quot; name=&quot;checked&quot; value=&quot;value1&quot; checked=&quot;checked&quot; /&gt;
                                              &lt;input type=&quot;radio&quot; value=&quot;radiovalue1&quot; name=&quot;radio1&quot; /&gt;
                                              &lt;input type=&quot;radio&quot; value=&quot;radiovalue2&quot; name=&quot;radio1&quot; checked=&quot;checked&quot; /&gt;
                                              &lt;select name=&quot;select&quot;&gt;&lt;option value=&quot;1&quot;&gt;1&lt;/option&gt;&lt;option value=&quot;2&quot; selected&gt;2&lt;/option&gt;&lt;/select&gt;
                                            &lt;/form&gt;&quot;&quot;&quot;
        dropzone = new Dropzone element, url: &quot;/the/url&quot;


        formData = null
        dropzone.on &quot;sending&quot;, (file, xhr, tformData) -&gt;
          formData = tformData
          sinon.spy tformData, &quot;append&quot;

        mock1 = getMockFile()

        dropzone.addFile mock1

        setTimeout -&gt;
          formData.append.callCount.should.equal 5

          formData.append.args[0][0].should.eql &quot;test&quot;
          formData.append.args[0][1].should.eql &quot;hidden&quot;

          formData.append.args[1][0].should.eql &quot;checked&quot;
          formData.append.args[1][1].should.eql &quot;value1&quot;

          formData.append.args[2][0].should.eql &quot;radio1&quot;
          formData.append.args[2][1].should.eql &quot;radiovalue2&quot;

          formData.append.args[3][0].should.eql &quot;select&quot;
          formData.append.args[3][1].should.eql &quot;2&quot;

          formData.append.args[4][0].should.eql &quot;file&quot;
          formData.append.args[4][1].should.equal mock1

          # formData.append.args[1][0].should.eql &quot;myName[]&quot;
          done()
        , 10


      it &quot;should all values of a select that has the multiple attribute&quot;, (done) -&gt;
        element = Dropzone.createElement &quot;&quot;&quot;&lt;form action=&quot;/the/url&quot;&gt;
                                              &lt;select name=&quot;select&quot; multiple&gt;
                                                &lt;option value=&quot;value1&quot;&gt;1&lt;/option&gt;
                                                &lt;option value=&quot;value2&quot; selected&gt;2&lt;/option&gt;
                                                &lt;option value=&quot;value3&quot;&gt;3&lt;/option&gt;
                                                &lt;option value=&quot;value4&quot; selected&gt;4&lt;/option&gt;
                                              &lt;/select&gt;
                                            &lt;/form&gt;&quot;&quot;&quot;
        dropzone = new Dropzone element, url: &quot;/the/url&quot;


        formData = null
        dropzone.on &quot;sending&quot;, (file, xhr, tformData) -&gt;
          formData = tformData
          sinon.spy tformData, &quot;append&quot;

        mock1 = getMockFile()

        dropzone.addFile mock1

        setTimeout -&gt;
          formData.append.callCount.should.equal 3

          formData.append.args[0][0].should.eql &quot;select&quot;
          formData.append.args[0][1].should.eql &quot;value2&quot;

          formData.append.args[1][0].should.eql &quot;select&quot;
          formData.append.args[1][1].should.eql &quot;value4&quot;

          formData.append.args[2][0].should.eql &quot;file&quot;
          formData.append.args[2][1].should.equal mock1

          # formData.append.args[1][0].should.eql &quot;myName[]&quot;
          done()
        , 10



      describe &quot;settings()&quot;, -&gt;
        it &quot;should correctly set `withCredentials` on the xhr object&quot;, -&gt;
          dropzone.uploadFile mockFile
          requests.length.should.eql 1
          requests[0].withCredentials.should.eql no
          dropzone.options.withCredentials = yes
          dropzone.uploadFile mockFile
          requests.length.should.eql 2
          requests[1].withCredentials.should.eql yes

        it &quot;should correctly override headers on the xhr object&quot;, -&gt;
          dropzone.options.headers = {&quot;Foo-Header&quot;: &quot;foobar&quot;}
          dropzone.uploadFile mockFile
          requests[0].requestHeaders[&quot;Foo-Header&quot;].should.eql 'foobar'

        it &quot;should not set headers on the xhr object that are empty&quot;, -&gt;
          dropzone.options.headers = {&quot;X-Requested-With&quot;: null}
          dropzone.uploadFile mockFile
          Object.keys(requests[0].requestHeaders).should.not.contain(&quot;X-Requested-With&quot;)

        it &quot;should properly use the paramName without [n] as file upload if uploadMultiple is false&quot;, (done) -&gt;
          dropzone.options.uploadMultiple = false
          dropzone.options.paramName = &quot;myName&quot;

          formData = [ ]
          sendingCount = 0
          dropzone.on &quot;sending&quot;, (files, xhr, tformData) -&gt;
            sendingCount++

            formData.push tformData
            sinon.spy tformData, &quot;append&quot;


          mock1 = getMockFile()
          mock2 = getMockFile()

          dropzone.addFile mock1
          dropzone.addFile mock2

          setTimeout -&gt;
            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 &quot;myName&quot;
            formData[0].append.args[0][0].should.eql &quot;myName&quot;

            done()
          , 10


        it &quot;should properly use the paramName with [n] as file upload if uploadMultiple is true&quot;, (done) -&gt;
          dropzone.options.uploadMultiple = yes
          dropzone.options.paramName = &quot;myName&quot;

          formData = null
          sendingMultipleCount = 0
          sendingCount = 0
          dropzone.on &quot;sending&quot;, (file, xhr, tformData) -&gt; sendingCount++
          dropzone.on &quot;sendingmultiple&quot;, (files, xhr, tformData) -&gt;
            sendingMultipleCount++
            formData = tformData
            sinon.spy tformData, &quot;append&quot;

          mock1 = getMockFile()
          mock2 = getMockFile()

          dropzone.addFile mock1
          dropzone.addFile mock2

          setTimeout -&gt;
            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 &quot;myName[0]&quot;
            formData.append.args[1][0].should.eql &quot;myName[1]&quot;
            done()
          , 10


      it &quot;should not change the file name if the options.renameFilename is not set&quot;, (done) -&gt;
        mockFilename = 'T3sT ;:_-.,!¨@&amp;%&amp;'

        renamedFilename = dropzone._renameFilename(mockFilename)

        setTimeout -&gt;
          renamedFilename.should.equal mockFilename
          done()
        , 10

      it &quot;should rename the file name if options.renamedFilename is set&quot;, (done) -&gt;
        dropzone.options.renameFilename = (name) -&gt;
          name.toLowerCase().replace(/[^\w]/gi, '')
        renamedFilename = dropzone._renameFilename('T3sT ;:_-.,!¨@&amp;%&amp;')
        setTimeout -&gt;
          renamedFilename.should.equal 't3st_'
          done()
        , 10

      describe &quot;should properly set status of file&quot;, -&gt;
        it &quot;should correctly set `withCredentials` on the xhr object&quot;, (done) -&gt;
          dropzone.addFile mockFile

          setTimeout -&gt;
            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

            setTimeout -&gt;
              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
              done()
            , 10
          , 10

    describe &quot;complete file&quot;, -&gt;
      it &quot;should properly emit the queuecomplete event when the complete queue is finished&quot;, (done) -&gt;

        mock1 = getMockFile()
        mock2 = getMockFile()
        mock3 = getMockFile()
        mock1.status = Dropzone.ADDED
        mock2.status = Dropzone.ADDED
        mock3.status = Dropzone.ADDED
        mock1.name = &quot;mock1&quot;
        mock2.name = &quot;mock2&quot;
        mock3.name = &quot;mock3&quot;


        dropzone.uploadFiles = (files) -&gt;
          setTimeout (=&gt;
            @_finished files, null, null
          ), 1

        completedFiles = 0
        dropzone.on &quot;complete&quot;, (file) -&gt;
          completedFiles++

        dropzone.on &quot;queuecomplete&quot;, -&gt;
          completedFiles.should.equal 3
          done()

        dropzone.addFile mock1
        dropzone.addFile mock2
        dropzone.addFile mock3
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fnudhamca%2Fclient.nudhamcapital.co.uk%2Fdist%2Fassets%2Fnode_modules%2Fdropzone-master%2Ftest'>Back to Directory</a>