RubyGems - unpoly-rails - Versions diffs - 0.32.0 → 0.33.0 - Mend

unpoly-rails 0.32.0 → 0.33.0

Potentially problematic release.

This version of unpoly-rails might be problematic. Click here for more details.

Files changed (232) hide show

data/spec_app/spec/javascripts/up/{flow_spec.js.coffee → dom_spec.js.coffee} RENAMED Viewed

@@ -1,4 +1,4 @@
-describe 'up.flow', ->
+describe 'up.dom', ->
   u = up.util
@@ -47,18 +47,33 @@ describe 'up.flow', ->
           expect(resolution).toHaveBeenCalled()
           expect($('.middle')).toHaveText('new-middle')
-        it 'returns a promise that will be resolved once the server response was received and the swap animations have completed', (done) ->
-          resolution = jasmine.createSpy()
-          promise = up.replace('.middle', '/path', transition: 'cross-fade', duration: 50)
-          promise.then(resolution)
-          expect(resolution).not.toHaveBeenCalled()
-          expect($('.middle')).toHaveText('old-middle')
-          @respond()
-          expect(resolution).not.toHaveBeenCalled()
-          u.setTimer 20, ->
+        describe 'transitions', ->
+          it 'returns a promise that will be resolved once the server response was received and the swap transition has completed', (done) ->
+            resolution = jasmine.createSpy()
+            promise = up.replace('.middle', '/path', transition: 'cross-fade', duration: 50)
+            promise.then(resolution)
             expect(resolution).not.toHaveBeenCalled()
-            u.setTimer 80, ->
-              expect(resolution).toHaveBeenCalled()
+            expect($('.middle')).toHaveText('old-middle')
+            @respond()
+            expect(resolution).not.toHaveBeenCalled()
+            u.setTimer 20, ->
+              expect(resolution).not.toHaveBeenCalled()
+              u.setTimer 80, ->
+                expect(resolution).toHaveBeenCalled()
+                done()
+          it 'ignores a { transition } option when replacing the body element', (done) ->
+            up.dom.knife.mock('swapBody') # can't have the example replace the Jasmine test runner UI
+            up.dom.knife.mock('destroy')  # if we don't swap the body, up.dom will destroy it
+            replaceCallback = jasmine.createSpy()
+            promise = up.replace('body', '/path', transition: 'cross-fade', duration: 50)
+            promise.then(replaceCallback)
+            expect(replaceCallback).not.toHaveBeenCalled()
+            @responseText = '<body>new text</body>'
+            @respond()
+            u.nextFrame ->
+              expect(replaceCallback).toHaveBeenCalled()
               done()
         describe 'when the server signals a redirect with X-Up-Location header (bugfix, logic should be moved to up.proxy)', ->
@@ -110,13 +125,14 @@ describe 'up.flow', ->
           up.replace('.middle', '/path', method: 'put')
           expect(@lastRequest()).toHaveRequestMethod('PUT')
-        describe 'if the server responds with a non-200 status code', ->
+        describe 'when the server responds with a non-200 status code', ->
           it 'replaces the <body> instead of the given selector', ->
-            implantSpy = up.flow.knife.mock('extract') # can't have the example replace the Jasmine test runner UI
+            # can't have the example replace the Jasmine test runner UI
+            extractSpy = up.dom.knife.mock('extract').and.returnValue(u.resolvedPromise())
             up.replace('.middle', '/path')
             @respond(status: 500)
-            expect(implantSpy).toHaveBeenCalledWith('body', jasmine.any(String), jasmine.any(Object))
+            expect(extractSpy).toHaveBeenCalledWith('body', jasmine.any(String), jasmine.any(Object))
           it 'uses a target selector given as { failTarget } option', ->
             up.replace('.middle', '/path', failTarget: '.after')
@@ -124,6 +140,34 @@ describe 'up.flow', ->
             expect($('.middle')).toHaveText('old-middle')
             expect($('.after')).toHaveText('new-after')
+          it 'rejects the returned promise', ->
+            affix('.after')
+            promise = up.replace('.middle', '/path', failTarget: '.after')
+            expect(promise.state()).toEqual('pending')
+            @respond(status: 500)
+            expect(promise.state()).toEqual('rejected')
+        describe 'when the request times out', ->
+          it "doesn't crash and rejects the returned promise", (done) ->
+            jasmine.clock().install() # required by responseTimeout()
+            affix('.target')
+            promise = up.replace('.middle', '/path', timeout: 10 * 1000)
+            expect(promise.state()).toEqual('pending')
+            jasmine.clock().tick(11 * 1000)
+            expect(promise.state()).toEqual('rejected')
+            done()
+        describe 'when there is a network issue', ->
+          it "doesn't crash and rejects the returned promise", (done) ->
+            affix('.target')
+            promise = up.replace('.middle', '/path')
+            @lastRequest().responseError()
+            u.nextFrame ->
+              expect(promise.state()).toEqual('rejected')
+              done()
         describe 'history', ->
           it 'should set the browser location to the given URL', (done) ->
@@ -194,47 +238,29 @@ describe 'up.flow', ->
             up.replace('.middle', '/path', method: 'post')
             @respond()
             expect($('.middle')).toHaveText('new-middle')
-            expect(up.flow.source('.middle')).toEndWith('/previous-source')
+            expect(up.dom.source('.middle')).toEndWith('/previous-source')
           describe 'if a URL is given as { source } option', ->
             it 'uses that URL as the source for a GET request', ->
               promise = up.replace('.middle', '/path', source: '/given-path')
               @respond()
-              expect(up.flow.source('.middle')).toEndWith('/given-path')
+              expect(up.dom.source('.middle')).toEndWith('/given-path')
             it 'uses that URL as the source after a non-GET request', ->
               promise = up.replace('.middle', '/path', method: 'post', source: '/given-path')
               @respond()
-              expect(up.flow.source('.middle')).toEndWith('/given-path')
+              expect(up.dom.source('.middle')).toEndWith('/given-path')
             it 'ignores the option and reuses the previous source after a failed non-GET request', ->
               @oldMiddle.attr('up-source', '/previous-source')
               promise = up.replace('.middle', '/path', method: 'post', source: '/given-path', failTarget: '.middle')
               @respond(status: 500)
-              expect(up.flow.source('.middle')).toEndWith('/previous-source')
-        it 'understands non-standard CSS selector extensions such as :has(...)', (done) ->
-          $first = affix('.boxx#first')
-          $firstChild = $('<span class="first-child">old first</span>').appendTo($first)
-          $second = affix('.boxx#second')
-          $secondChild = $('<span class="second-child">old second</span>').appendTo($second)
-          promise = up.replace('.boxx:has(.first-child)', '/path')
-          @respondWith """
-            <div class="boxx" id="first">
-              <span class="first-child">new first</span>
-            </div>
-            """
-          promise.then ->
-            expect($('#first span')).toHaveText('new first')
-            expect($('#second span')).toHaveText('old second')
-            done()
+              expect(up.dom.source('.middle')).toEndWith('/previous-source')
         describe 'document title', ->
-          it "sets the document title to a 'title' tag in the response", ->
+          it "sets the document title to the response <title>", ->
             affix('.container').text('old container text')
             up.replace('.container', '/path')
             @respondWith """
@@ -266,6 +292,45 @@ describe 'up.flow', ->
             expect($('.container')).toHaveText('new container text')
             expect(document.title).toBe('Title from header')
+          it "prefers the X-Up-Title header to the response <title>", ->
+            affix('.container').text('old container text')
+            up.replace('.container', '/path')
+            @respondWith
+              responseHeaders:
+                'X-Up-Title': 'Title from header'
+              responseText: """
+                <html>
+                  <head>
+                    <title>Title from HTML</title>
+                  </head>
+                  <body>
+                    <div class='container'>
+                      new container text
+                    </div>
+                  </body>
+                </html>
+              """
+            expect($('.container')).toHaveText('new container text')
+            expect(document.title).toBe('Title from header')
+          it "sets the document title to the response <title> with { history: false, title: true } options (bugfix)", ->
+            affix('.container').text('old container text')
+            up.replace('.container', '/path', history: false, title: true)
+            @respondWith """
+              <html>
+                <head>
+                  <title>Title from HTML</title>
+                </head>
+                <body>
+                  <div class='container'>
+                    new container text
+                  </div>
+                </body>
+              </html>
+            """
+            expect($('.container')).toHaveText('new container text')
+            expect(document.title).toBe('Title from HTML')
           it "does not extract the title from the response or HTTP header if history isn't updated", ->
             affix('.container').text('old container text')
             document.title = 'old document title'
@@ -345,6 +410,191 @@ describe 'up.flow', ->
               expect($('.after')).toHaveText('old-afternew-after')
               done()
+          it 'understands non-standard CSS selector extensions such as :has(...)', (done) ->
+            $first = affix('.boxx#first')
+            $firstChild = $('<span class="first-child">old first</span>').appendTo($first)
+            $second = affix('.boxx#second')
+            $secondChild = $('<span class="second-child">old second</span>').appendTo($second)
+            promise = up.replace('.boxx:has(.first-child)', '/path')
+            @respondWith """
+              <div class="boxx" id="first">
+                <span class="first-child">new first</span>
+              </div>
+              """
+            promise.then ->
+              expect($('#first span')).toHaveText('new first')
+              expect($('#second span')).toHaveText('old second')
+              done()
+          describe 'when selectors are missing on the page before the request was made', ->
+            beforeEach ->
+              up.dom.config.fallbacks = []
+            it 'tries selectors from options.fallback before making a request', ->
+              affix('.box').text('old box')
+              up.replace('.unknown', '/path', fallback: '.box')
+              @respondWith '<div class="box">new box</div>'
+              expect('.box').toHaveText('new box')
+            it 'throws an error if all alternatives are exhausted', ->
+              replacement = -> up.replace('.unknown', '/path', fallback: '.more-unknown')
+              expect(replacement).toThrowError(/Could not find target in current page/i)
+            it 'considers a union selector to be missing if one of its selector-atoms are missing', ->
+              affix('.target').text('old target')
+              affix('.fallback').text('old fallback')
+              up.replace('.target, .unknown', '/path', fallback: '.fallback')
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="fallback">new fallback</div>
+              """
+              expect('.target').toHaveText('old target')
+              expect('.fallback').toHaveText('new fallback')
+            it 'tries a selector from up.dom.config.fallbacks if options.fallback is missing', ->
+              up.dom.config.fallbacks = ['.existing']
+              affix('.existing').text('old existing')
+              up.replace('.unknown', '/path')
+              @respondWith '<div class="existing">new existing</div>'
+              expect('.existing').toHaveText('new existing')
+            it 'does not try a selector from up.dom.config.fallbacks if options.fallback is false', ->
+              up.dom.config.fallbacks = ['.existing']
+              affix('.existing').text('old existing')
+              replacement = -> up.replace('.unknown', '/path', fallback: false)
+              expect(replacement).toThrowError(/Could not find target in current page/i)
+          describe 'when selectors are missing on the page after the request was made', ->
+            beforeEach ->
+              up.dom.config.fallbacks = []
+            it 'tries selectors from options.fallback before swapping elements', ->
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path', fallback: '.fallback')
+              $target.remove()
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="fallback">new fallback</div>
+              """
+              expect('.fallback').toHaveText('new fallback')
+            it 'throws an error if all alternatives are exhausted', ->
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path', fallback: '.fallback')
+              $target.remove()
+              $fallback.remove()
+              respond = =>
+                @respondWith """
+                  <div class="target">new target</div>
+                  <div class="fallback">new fallback</div>
+                """
+              expect(respond).toThrowError(/Could not find target in current page/i)
+            it 'considers a union selector to be missing if one of its selector-atoms are missing', ->
+              $target = affix('.target').text('old target')
+              $target2 = affix('.target2').text('old target2')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target, .target2', '/path', fallback: '.fallback')
+              $target2.remove()
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="target2">new target2</div>
+                <div class="fallback">new fallback</div>
+              """
+              expect('.target').toHaveText('old target')
+              expect('.fallback').toHaveText('new fallback')
+            it 'tries a selector from up.dom.config.fallbacks if options.fallback is missing', ->
+              up.dom.config.fallbacks = ['.fallback']
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path')
+              $target.remove()
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="fallback">new fallback</div>
+              """
+              expect('.fallback').toHaveText('new fallback')
+            it 'does not try a selector from up.dom.config.fallbacks if options.fallback is false', ->
+              up.dom.config.fallbacks = ['.fallback']
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path', fallback: false)
+              $target.remove()
+              respond = =>
+                @respondWith """
+                  <div class="target">new target</div>
+                  <div class="fallback">new fallback</div>
+                """
+              expect(respond).toThrowError(/Could not find target in current page/i)
+          describe 'when selectors are missing in the response', ->
+            beforeEach ->
+              up.dom.config.fallbacks = []
+            it 'tries selectors from options.fallback before swapping elements', ->
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path', fallback: '.fallback')
+              @respondWith """
+                <div class="fallback">new fallback</div>
+              """
+              expect('.target').toHaveText('old target')
+              expect('.fallback').toHaveText('new fallback')
+            it 'throws an error if all alternatives are exhausted', ->
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path', fallback: '.fallback')
+              respond = =>
+                @respondWith """
+                  <div class="unexpected">new unexpected</div>
+                """
+              expect(respond).toThrowError(/Could not find target in response/i)
+            it 'considers a union selector to be missing if one of its selector-atoms are missing', ->
+              $target = affix('.target').text('old target')
+              $target2 = affix('.target2').text('old target2')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target, .target2', '/path', fallback: '.fallback')
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="fallback">new fallback</div>
+              """
+              expect('.target').toHaveText('old target')
+              expect('.target2').toHaveText('old target2')
+              expect('.fallback').toHaveText('new fallback')
+            it 'tries a selector from up.dom.config.fallbacks if options.fallback is missing', ->
+              up.dom.config.fallbacks = ['.fallback']
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path')
+              @respondWith """
+                <div class="fallback">new fallback</div>
+              """
+              expect('.target').toHaveText('old target')
+              expect('.fallback').toHaveText('new fallback')
+            it 'does not try a selector from up.dom.config.fallbacks if options.fallback is false', ->
+              up.dom.config.fallbacks = ['.fallback']
+              $target = affix('.target').text('old target')
+              $fallback = affix('.fallback').text('old fallback')
+              up.replace('.target', '/path', fallback: false)
+              respond = =>
+                @respondWith """
+                  <div class="fallback">new fallback</div>
+                """
+              expect(respond).toThrowError(/Could not find target in response/i)
         describe 'execution of script tags', ->
           beforeEach ->
@@ -377,8 +627,8 @@ describe 'up.flow', ->
                 expect(window.scriptTagExecuted).toHaveBeenCalledWith('middle')
                 done()
-            it 'does not execute script-tags if up.flow.config.runInlineScripts is set to false', (done) ->
-              up.flow.config.runInlineScripts = false
+            it 'does not execute script-tags if up.dom.config.runInlineScripts is set to false', (done) ->
+              up.dom.config.runInlineScripts = false
               @responseText = """
                 <div class="middle">
@@ -429,8 +679,8 @@ describe 'up.flow', ->
                   expect(window.scriptTagExecuted).not.toHaveBeenCalled()
                   done()
-            it 'does execute linked scripts if up.flow.config.runLinkedScripts is set to true', (done) ->
-              up.flow.config.runLinkedScripts = true
+            it 'does execute linked scripts if up.dom.config.runLinkedScripts is set to true', (done) ->
+              up.dom.config.runLinkedScripts = true
               @responseText = """
                 <div class="middle">
@@ -609,12 +859,12 @@ describe 'up.flow', ->
       it "throws an error if the selector can't be found on the current page", ->
         html = '<div class="foo-bar">text</div>'
         extract = -> up.extract('.foo-bar', html)
-        expect(extract).toThrowError(/Could not find selector ".foo-bar"/i)
+        expect(extract).toThrowError(/Could not find selector in current page, modal or popup/i)
       it "throws an error if the selector can't be found in the given HTML string", ->
         affix('.foo-bar')
         extract = -> up.extract('.foo-bar', '')
-        expect(extract).toThrowError(/Could not find selector ".foo-bar" in response/i)
+        expect(extract).toThrowError(/Could not find selector in response/i)
       it "ignores an element that matches the selector but also matches .up-destroying", ->
         html = '<div class="foo-bar">text</div>'

data/spec_app/spec/javascripts/up/{navigation_spec.js.coffee → feedback_spec.js.coffee} RENAMED Viewed

@@ -1,4 +1,4 @@
-describe 'up.navigation', ->
+describe 'up.feedback', ->
   u = up.util
@@ -57,7 +57,7 @@ describe 'up.navigation', ->
         expect($otherLink).not.toHaveClass('up-current')
       it 'allows to configure a custom "current" class, but always also sets .up-current', ->
-        up.navigation.config.currentClasses = ['highlight']
+        up.feedback.config.currentClasses = ['highlight']
         spyOn(up.browser, 'url').and.returnValue('/foo')
         $currentLink = up.hello(affix('a[href="/foo"]'))
         expect($currentLink).toHaveClass('highlight up-current')

data/spec_app/spec/javascripts/up/form_spec.js.coffee CHANGED Viewed

@@ -422,6 +422,7 @@ describe 'up.form', ->
       it 'runs the JavaScript code in the attribute value when a change is observed in the field', (done) ->
         $form = affix('form')
         window.observeCallbackSpy = jasmine.createSpy('observe callback')
+        console.debug("*** Setting attribute: %o", 'window.observeCallbackSpy(value, $field.get(0))')
         $field = $form.affix('input[val="old-value"][up-observe="window.observeCallbackSpy(value, $field.get(0))"]')
         up.hello($form)
         $field.val('new-value')

data/spec_app/spec/javascripts/up/layout_spec.js.coffee CHANGED Viewed

@@ -54,6 +54,16 @@ describe 'up.layout', ->
           # ---------------------
           expect($(document).scrollTop()).toBe(@clientHeight + 50)
+        it "includes the element's top margin in the revealed area", ->
+          @$elements[1].css('margin-top': '20px')
+          up.reveal(@$elements[1])
+          expect($(document).scrollTop()).toBe(50 + 20)
+        it "includes the element's bottom margin in the revealed area", ->
+          @$elements[1].css('margin-bottom': '20px')
+          up.reveal(@$elements[2])
+          expect($(document).scrollTop()).toBe(@clientHeight + 50 + 20)
         it 'snaps to the top if the space above the future-visible area is smaller than the value of config.snap', ->
           up.layout.config.snap = 30

data/spec_app/spec/javascripts/up/link_spec.js.coffee CHANGED Viewed

@@ -440,6 +440,34 @@ describe 'up.link', ->
                 expect(u.opacity($newGhost)).toBeAround(0.5, 0.15)
                 done()
+        describe 'wih a CSS selector in the [up-fallback] attribute', ->
+          it 'uses the fallback selector if the [up-target] CSS does not exist on the page', ->
+            affix('.fallback').text('old fallback')
+            $link = affix('a[href="/path"][up-target=".target"][up-fallback=".fallback"]')
+            Trigger.clickSequence($link)
+            u.nextFrame ->
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="fallback">new fallback</div>
+              """
+              u.nextFrame ->
+                expect('.target').toHaveText('new fallback')
+          it 'ignores the fallback selector if the [up-target] CSS exists on the page', ->
+            affix('.target').text('old target')
+            affix('.fallback').text('old fallback')
+            $link = affix('a[href="/path"][up-target=".target"][up-fallback=".fallback"]')
+            Trigger.clickSequence($link)
+            u.nextFrame ->
+              @respondWith """
+                <div class="target">new target</div>
+                <div class="fallback">new fallback</div>
+              """
+              u.nextFrame ->
+                expect('.target').toHaveText('new target')
+                expect('.fallback').toHaveText('old fallback')
       it 'does not add a history entry when an up-history attribute is set to "false"', ->
         oldPathname = location.pathname
         affix('.target')

data/spec_app/spec/javascripts/up/modal_spec.js.coffee CHANGED Viewed

@@ -47,6 +47,39 @@ describe 'up.modal', ->
     describe 'up.modal.visit', ->
+      it "requests the given URL and places the given selector into a modal", ->
+        up.modal.visit '/foo', target: '.middle'
+        @respondWith """
+          <div class="before">new-before</div>
+          <div class="middle">new-middle</div>
+          <div class="after">new-after</div>
+        """
+        expect('.up-modal').toExist()
+        expect('.up-modal-dialog').toExist()
+        expect('.up-modal-dialog .middle').toExist()
+        expect('.up-modal-dialog .middle').toHaveText('new-middle')
+        expect('.up-modal-dialog .before').not.toExist()
+        expect('.up-modal-dialog .after').not.toExist()
+        expect(location.pathname).toEndWith('/foo')
+      it "doesn't create an .up-modal frame and replaces { failTarget } if the server returns a non-200 response", ->
+        affix('.error').text('old error')
+        up.modal.visit '/foo', target: '.target', failTarget: '.error'
+        @respondWith
+          status: 500
+          responseText: """
+            <div class="target">new target</div>
+            <div class="error">new error</div>
+          """
+        expect('.up-modal').not.toExist()
+        expect('.error').toHaveText('new error')
       describe 'preventing elements from jumping as scrollbars change', ->
         it "brings its own scrollbar, padding the body on the right", (done) ->
@@ -79,10 +112,11 @@ describe 'up.modal', ->
             openPromise.then ->
               expect($modal.css('overflow-y')).not.toEqual('scroll')
               expect($viewport.css('overflow-y')).toEqual('scroll')
-              closePromise = up.modal.close(animation: 'fade-out', duration: 100)
-              expect($modal.css('overflow-y')).toEqual('scroll')
-              expect($viewport.css('overflow-y')).toEqual('hidden')
-              done()
+              closePromise = up.modal.close(animation: 'fade-out', duration: 200)
+              u.nextFrame ->
+                expect($modal.css('overflow-y')).toEqual('scroll')
+                expect($viewport.css('overflow-y')).toEqual('hidden')
+                done()
         it 'does not add right padding to the body if the body has overflow-y: hidden', (done) ->
           restoreBody = u.temporaryCss($('body'), 'overflow-y': 'hidden')
@@ -138,7 +172,9 @@ describe 'up.modal', ->
           promise2 = up.modal.visit('/path2', target: '.container', animation: 'fade-in', duration: 50)
           @respondWith('<div class="container">response1</div>')
-          u.setTimer 80, =>
+          u.setTimer 120, =>
+            # up.modal.visit (visitAsap) will start the request only after the last modal
+            # has finished opening and closing: 50 + 10 ms
             @respondWith('<div class="container">response2</div>')
             $.when(promise1, promise2).then ->
               expect($('.up-modal').length).toBe(1)
@@ -155,7 +191,7 @@ describe 'up.modal', ->
             up.modal.config.openAnimation = 'fade-in'
             up.modal.config.openDuration = 5
             up.modal.config.closeAnimation = 'fade-out'
-            up.modal.config.closeDuration = 50
+            up.modal.config.closeDuration = 60
             events = []
             u.each ['up:modal:open', 'up:modal:opened', 'up:modal:close', 'up:modal:closed'], (event) ->
@@ -168,22 +204,23 @@ describe 'up.modal', ->
             expect(events).toEqual ['up:modal:open']
             expect($('.target')).toHaveText('response1')
-            u.setTimer 40, ->
+            u.setTimer 80, ->
               # First modal has completed opening animation
               expect(events).toEqual ['up:modal:open', 'up:modal:opened']
               expect($('.target')).toHaveText('response1')
+              # We open another modal, which will cause the first modal to start closing
               up.modal.extract('.target', '<div class="target">response2</div>')
               expect($('.target')).toHaveText('response1')
-              u.setTimer 40, ->
+              u.setTimer 20, ->
                 # Second modal is still waiting for first modal's closing animaton to finish.
                 expect(events).toEqual ['up:modal:open', 'up:modal:opened', 'up:modal:close']
                 expect($('.target')).toHaveText('response1')
-                u.setTimer 100, ->
+                u.setTimer 200, ->
                   # First modal has finished closing, second modal has finished opening.
                   expect(events).toEqual ['up:modal:open', 'up:modal:opened', 'up:modal:close', 'up:modal:closed', 'up:modal:open', 'up:modal:opened']