unpoly-rails 0.37.0 → 0.50.0

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

@@ -8,41 +8,45 @@ describe 'up.link', ->
 
       describeCapability 'canPushState', ->
 
-        it 'loads the given link via AJAX and replaces the response in the given target', (done) ->
+        it 'loads the given link via AJAX and replaces the response in the given target', asyncSpec (next) ->
           affix('.before').text('old-before')
           affix('.middle').text('old-middle')
           affix('.after').text('old-after')
           $link = affix('a[href="/path"][up-target=".middle"]')
     
-          promise = up.follow($link)
-    
-          @respondWith """
-            <div class="before">new-before</div>
-            <div class="middle">new-middle</div>
-            <div class="after">new-after</div>
-            """
-          
-          promise.then ->
+          up.follow($link)
+
+          next =>
+            @respondWith """
+              <div class="before">new-before</div>
+              <div class="middle">new-middle</div>
+              <div class="after">new-after</div>
+              """
+
+          next =>
             expect($('.before')).toHaveText('old-before')
             expect($('.middle')).toHaveText('new-middle')
             expect($('.after')).toHaveText('old-after')
-            done()
 
-        it 'uses the method from a data-method attribute', ->
+        it 'uses the method from a data-method attribute', asyncSpec (next) ->
           $link = affix('a[href="/path"][data-method="PUT"]')
           up.follow($link)
-          request = @lastRequest()
-          expect(request).toHaveRequestMethod('PUT')
 
-        it 'allows to refer to the link itself as "&" in the CSS selector', ->
+          next =>
+            request = @lastRequest()
+            expect(request).toHaveRequestMethod('PUT')
+
+        it 'allows to refer to the link itself as "&" in the CSS selector', asyncSpec (next) ->
           $container = affix('div')
           $link1 = $('<a id="first" href="/path" up-target="&">first-link</a>').appendTo($container)
           $link2 = $('<a id="second" href="/path" up-target="&">second-link</a>').appendTo($container)
           up.follow($link2)
-          @respondWith '<div id="second">second-div</div>'
-          expect($container.text()).toBe('first-linksecond-div')
 
-        it 'adds history entries and allows the user to use the back- and forward-buttons', (done) ->
+          next => @respondWith '<div id="second">second-div</div>'
+          next => expect($container.text()).toBe('first-linksecond-div')
+
+        it 'adds history entries and allows the user to use the back- and forward-buttons', asyncSpec (next) ->
+          up.history.config.enabled = true
 
           waitForBrowser = 70
 
@@ -58,10 +62,10 @@ describe 'up.link', ->
               responseText: "<div class='container'><div class='target'>#{html}</div></div>"
               responseHeaders: { 'X-Up-Title': title }
 
-          followAndRespond = ($link, html, title) ->
-            promise = up.follow($link)
-            respondWith(html, title)
-            promise
+#          followAndRespond = ($link, html, title) ->
+#            promise = up.follow($link)
+#            respondWith(html, title)
+#            promise
 
           $link1 = affix('a[href="/one"][up-target=".target"]')
           $link2 = affix('a[href="/two"][up-target=".target"]')
@@ -69,45 +73,66 @@ describe 'up.link', ->
           $container = affix('.container')
           $target = affix('.target').appendTo($container).text('original text')
 
-          followAndRespond($link1, 'text from one', 'title from one').then =>
+          up.follow($link1)
+
+          next =>
+            respondWith('text from one', 'title from one')
+
+          next =>
             expect($('.target')).toHaveText('text from one')
             expect(location.pathname).toEqual('/one')
             expect(document.title).toEqual('title from one')
 
-            followAndRespond($link2, 'text from two', 'title from two').then =>
-              expect($('.target')).toHaveText('text from two')
-              expect(location.pathname).toEqual('/two')
-              expect(document.title).toEqual('title from two')
-
-              followAndRespond($link3, 'text from three', 'title from three').then =>
-                expect($('.target')).toHaveText('text from three')
-                expect(location.pathname).toEqual('/three')
-                expect(document.title).toEqual('title from three')
-
-                history.back()
-                u.setTimer waitForBrowser, ->
-                  respondWith('restored text from two', 'restored title from two')
-                  expect($('.target')).toHaveText('restored text from two')
-                  expect(location.pathname).toEqual('/two')
-                  expect(document.title).toEqual('restored title from two')
-
-                  history.back()
-                  u.setTimer waitForBrowser, ->
-                    respondWith('restored text from one', 'restored title from one')
-                    expect($('.target')).toHaveText('restored text from one')
-                    expect(location.pathname).toEqual('/one')
-                    expect(document.title).toEqual('restored title from one')
-
-                    history.forward()
-                    u.setTimer waitForBrowser, ->
-                      # Since the response is cached, we don't have to respond
-                      expect($('.target')).toHaveText('restored text from two', 'restored title from two')
-                      expect(location.pathname).toEqual('/two')
-                      expect(document.title).toEqual('restored title from two')
-
-                      done()
-
-        it 'does not add additional history entries when linking to the current URL', (done) ->
+            up.follow($link2)
+
+          next =>
+            respondWith('text from two', 'title from two')
+
+          next =>
+            expect($('.target')).toHaveText('text from two')
+            expect(location.pathname).toEqual('/two')
+            expect(document.title).toEqual('title from two')
+
+            up.follow($link3)
+
+          next =>
+            respondWith('text from three', 'title from three')
+
+          next =>
+            expect($('.target')).toHaveText('text from three')
+            expect(location.pathname).toEqual('/three')
+            expect(document.title).toEqual('title from three')
+
+            history.back()
+
+          next.after waitForBrowser, =>
+            respondWith('restored text from two', 'restored title from two')
+
+          next =>
+            expect($('.target')).toHaveText('restored text from two')
+            expect(location.pathname).toEqual('/two')
+            expect(document.title).toEqual('restored title from two')
+
+            history.back()
+
+          next.after waitForBrowser, =>
+            respondWith('restored text from one', 'restored title from one')
+
+          next =>
+            expect($('.target')).toHaveText('restored text from one')
+            expect(location.pathname).toEqual('/one')
+            expect(document.title).toEqual('restored title from one')
+
+            history.forward()
+
+          next.after waitForBrowser, =>
+            # Since the response is cached, we don't have to respond
+            expect($('.target')).toHaveText('restored text from two', 'restored title from two')
+            expect(location.pathname).toEqual('/two')
+            expect(document.title).toEqual('restored title from two')
+
+        it 'does not add additional history entries when linking to the current URL', asyncSpec (next) ->
+          up.history.config.enabled = true
 
           # By default, up.history will replace the <body> tag when
           # the user presses the back-button. We reconfigure this
@@ -123,43 +148,58 @@ describe 'up.link', ->
               </div>
             """
 
-          followAndRespond = ($link, text) =>
-            promise = up.follow($link)
-            respondWith(text)
-            promise
-
           $link1 = affix('a[href="/one"][up-target=".target"]')
           $link2 = affix('a[href="/two"][up-target=".target"]')
           $container = affix('.container')
           $target = affix('.target').appendTo($container).text('original text')
 
-          followAndRespond($link1, 'text from one').then =>
+          up.follow($link1)
+
+          next =>
+            respondWith('text from one')
+
+          next =>
             expect($('.target')).toHaveText('text from one')
             expect(location.pathname).toEqual('/one')
 
-            followAndRespond($link2, 'text from two').then =>
-              expect($('.target')).toHaveText('text from two')
-              expect(location.pathname).toEqual('/two')
+            up.follow($link2)
 
-              followAndRespond($link2, 'text from two').then =>
-                expect($('.target')).toHaveText('text from two')
-                expect(location.pathname).toEqual('/two')
+          next =>
+            respondWith('text from two')
 
-                history.back()
-                u.setTimer 50, ->
-                  respondWith('restored text from one')
-                  expect($('.target')).toHaveText('restored text from one')
-                  expect(location.pathname).toEqual('/one')
+          next =>
+            expect($('.target')).toHaveText('text from two')
+            expect(location.pathname).toEqual('/two')
 
-                  history.forward()
-                  u.setTimer 50, ->
-                    respondWith('restored text from two')
-                    expect($('.target')).toHaveText('restored text from two')
-                    expect(location.pathname).toEqual('/two')
+            up.follow($link2)
 
-                    done()
+          next =>
+            respondWith('text from two')
 
-        it 'does adds additional history entries when linking to the current URL, but with a different hash', (done) ->
+          next =>
+            expect($('.target')).toHaveText('text from two')
+            expect(location.pathname).toEqual('/two')
+
+            history.back()
+
+          next.after 50, =>
+            respondWith('restored text from one')
+
+          next =>
+            expect($('.target')).toHaveText('restored text from one')
+            expect(location.pathname).toEqual('/one')
+
+            history.forward()
+
+          next.after 50, =>
+            respondWith('restored text from two')
+
+          next =>
+            expect($('.target')).toHaveText('restored text from two')
+            expect(location.pathname).toEqual('/two')
+
+        it 'does adds additional history entries when linking to the current URL, but with a different hash', asyncSpec (next) ->
+          up.history.config.enabled = true
 
           # By default, up.history will replace the <body> tag when
           # the user presses the back-button. We reconfigure this
@@ -175,50 +215,68 @@ describe 'up.link', ->
               </div>
             """
 
-          followAndRespond = ($link, text) =>
-            promise = up.follow($link)
-            respondWith(text)
-            promise
-
           $link1 = affix('a[href="/one"][up-target=".target"]')
           $link2 = affix('a[href="/two"][up-target=".target"]')
           $link2WithHash = affix('a[href="/two#hash"][up-target=".target"]')
           $container = affix('.container')
           $target = affix('.target').appendTo($container).text('original text')
 
-          followAndRespond($link1, 'text from one').then =>
+          up.follow($link1)
+
+          next =>
+            respondWith('text from one')
+
+          next =>
             expect($('.target')).toHaveText('text from one')
             expect(location.pathname).toEqual('/one')
             expect(location.hash).toEqual('')
 
-            followAndRespond($link2, 'text from two').then =>
-              expect($('.target')).toHaveText('text from two')
-              expect(location.pathname).toEqual('/two')
-              expect(location.hash).toEqual('')
-
-              followAndRespond($link2WithHash, 'text from two with hash').then =>
-                expect($('.target')).toHaveText('text from two with hash')
-                expect(location.pathname).toEqual('/two')
-                expect(location.hash).toEqual('#hash')
-
-                history.back()
-                u.setTimer 50, ->
-                  respondWith('restored text from two')
-                  expect($('.target')).toHaveText('restored text from two')
-                  expect(location.pathname).toEqual('/two')
-                  expect(location.hash).toEqual('')
-
-                  history.forward()
-                  u.setTimer 50, ->
-                    respondWith('restored text from two with hash')
-                    expect($('.target')).toHaveText('restored text from two with hash')
-                    expect(location.pathname).toEqual('/two')
-                    expect(location.hash).toEqual('#hash')
-                    done()
+            up.follow($link2)
+
+          next =>
+            respondWith('text from two')
+
+          next =>
+            expect($('.target')).toHaveText('text from two')
+            expect(location.pathname).toEqual('/two')
+            expect(location.hash).toEqual('')
+
+            up.follow($link2WithHash)
+
+          next =>
+            respondWith('text from two with hash')
+
+          next =>
+            expect($('.target')).toHaveText('text from two with hash')
+            expect(location.pathname).toEqual('/two')
+            expect(location.hash).toEqual('#hash')
+
+            history.back()
+
+          next.after 50, =>
+            respondWith('restored text from two')
+
+          next =>
+            expect($('.target')).toHaveText('restored text from two')
+            expect(location.pathname).toEqual('/two')
+            expect(location.hash).toEqual('')
+
+            history.forward()
+
+          next.after 50, =>
+            respondWith('restored text from two with hash')
+
+          next =>
+            expect($('.target')).toHaveText('restored text from two with hash')
+            expect(location.pathname).toEqual('/two')
+            expect(location.hash).toEqual('#hash')
 
         describe 'with { restoreScroll: true } option', ->
 
-          it 'does not reveal, but instead restores the scroll positions of all viewports around the target', ->
+          beforeEach ->
+            up.history.config.enabled = true
+
+          it 'does not reveal, but instead restores the scroll positions of all viewports around the target', asyncSpec (next) ->
 
             $viewport = affix('div[up-viewport] .element').css
               'height': '100px'
@@ -237,76 +295,94 @@ describe 'up.link', ->
                 """
 
             up.replace('.element', '/foo')
-            # Provide the content at /foo with a link to /bar in the HTML
-            respond('/bar')
 
-            $viewport.scrollTop(65)
+            next =>
+              # Provide the content at /foo with a link to /bar in the HTML
+              respond('/bar')
+
+            next =>
+              $viewport.scrollTop(65)
+
+              # Follow the link to /bar
+              followLink()
+
+            next =>
+              # Provide the content at /bar with a link back to /foo in the HTML
+              respond('/foo')
 
-            # Follow the link to /bar
-            followLink()
+            next =>
+              # Follow the link back to /foo, restoring the scroll position of 65px
+              followLink(restoreScroll: true)
+              # No need to respond because /foo has been cached before
 
-            # Provide the content at /bar with a link back to /foo in the HTML
-            respond('/foo')
+            next =>
+              expect($viewport.scrollTop()).toEqual(65)
 
-            # Follow the link back to /foo, restoring the scroll position of 65px
-            followLink(restoreScroll: true)
-            # No need to respond because /foo has been cached before
+        describe "when the browser is already on the link's destination", ->
 
-            expect($viewport.scrollTop()).toEqual(65)
+          it "doesn't make a request and reveals the target container"
 
-#        describe "when the browser is already on the link's destination", ->
-#
-#          it "doesn't make a request and reveals the target container"
-#
-#          it "doesn't make a request and reveals the target of a #hash in the URL"
+          it "doesn't make a request and reveals the target of a #hash in the URL"
 
         describe 'with { confirm } option', ->
 
-          it 'follows the link after the user OKs a confirmation dialog', ->
+          it 'follows the link after the user OKs a confirmation dialog', asyncSpec (next) ->
             spyOn(up, 'replace')
             spyOn(window, 'confirm').and.returnValue(true)
             $link = affix('a[href="/danger"][up-target=".middle"]')
             up.follow($link, confirm: 'Do you really want to go there?')
-            expect(window.confirm).toHaveBeenCalledWith('Do you really want to go there?')
-            expect(up.replace).toHaveBeenCalled()
 
-          it 'does not follow the link if the user cancels the confirmation dialog', ->
+            next =>
+              expect(window.confirm).toHaveBeenCalledWith('Do you really want to go there?')
+              expect(up.replace).toHaveBeenCalled()
+
+          it 'does not follow the link if the user cancels the confirmation dialog', asyncSpec (next) ->
             spyOn(up, 'replace')
             spyOn(window, 'confirm').and.returnValue(false)
             $link = affix('a[href="/danger"][up-target=".middle"]')
             up.follow($link, confirm: 'Do you really want to go there?')
-            expect(window.confirm).toHaveBeenCalledWith('Do you really want to go there?')
-            expect(up.replace).not.toHaveBeenCalled()
 
-          it 'does not show a confirmation dialog if the option is not a present string', ->
+            next =>
+              expect(window.confirm).toHaveBeenCalledWith('Do you really want to go there?')
+              expect(up.replace).not.toHaveBeenCalled()
+
+          it 'does not show a confirmation dialog if the option is not a present string', asyncSpec (next) ->
             spyOn(up, 'replace')
             spyOn(window, 'confirm')
             $link = affix('a[href="/danger"][up-target=".middle"]')
             up.follow($link, confirm: '')
-            expect(window.confirm).not.toHaveBeenCalled()
-            expect(up.replace).toHaveBeenCalled()
 
-          it 'does not show a confirmation dialog when preloading', ->
+            next =>
+              expect(window.confirm).not.toHaveBeenCalled()
+              expect(up.replace).toHaveBeenCalled()
+
+          it 'does not show a confirmation dialog when preloading', asyncSpec (next) ->
             spyOn(up, 'replace')
             spyOn(window, 'confirm')
             $link = affix('a[href="/danger"][up-target=".middle"]')
             up.follow($link, confirm: 'Are you sure?', preload: true)
-            expect(window.confirm).not.toHaveBeenCalled()
-            expect(up.replace).toHaveBeenCalled()
+
+            next =>
+              expect(window.confirm).not.toHaveBeenCalled()
+              expect(up.replace).toHaveBeenCalled()
 
       describeFallback 'canPushState', ->
-        
-        it 'follows the given link', ->
+
+        it 'follows the given link', asyncSpec (next) ->
           $link = affix('a[href="/path"]')
-          spyOn(up.browser, 'loadPage')
+          spyOn(up.browser, 'navigate')
           up.follow($link)
-          expect(up.browser.loadPage).toHaveBeenCalledWith('/path', jasmine.anything())
 
-        it 'uses the method from a data-method attribute', ->
+          next =>
+            expect(up.browser.navigate).toHaveBeenCalledWith('/path', jasmine.anything())
+
+        it 'uses the method from a data-method attribute', asyncSpec (next) ->
           $link = affix('a[href="/path"][data-method="PUT"]')
-          spyOn(up.browser, 'loadPage')
+          spyOn(up.browser, 'navigate')
           up.follow($link)
-          expect(up.browser.loadPage).toHaveBeenCalledWith('/path', { method: 'PUT' })
+
+          next =>
+            expect(up.browser.navigate).toHaveBeenCalledWith('/path', { method: 'PUT' })
 
     describe 'up.link.makeFollowable', ->
 
@@ -331,126 +407,178 @@ describe 'up.link', ->
         expect($link.attr('up-follow')).toBeMissing()
 
     describe 'up.visit', ->
-      
+
       it 'should have tests'
 
+    describe 'up.link.isFollowable', ->
+
+      it 'returns true for an [up-target] link', ->
+        $link = affix('a[href="/foo"][up-target=".target"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(true)
+
+      it 'returns true for an [up-follow] link', ->
+        $link = affix('a[href="/foo"][up-follow]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(true)
+
+      it 'returns true for an [up-modal] link', ->
+        $link = affix('a[href="/foo"][up-modal=".target"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(true)
+
+      it 'returns true for an [up-popup] link', ->
+        $link = affix('a[href="/foo"][up-popup=".target"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(true)
+
+      it 'returns true for an [up-drawer] link', ->
+        $link = affix('a[href="/foo"][up-drawer=".target"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(true)
+
+      it 'returns true for an [up-target] span with [up-href]', ->
+        $link = affix('span[up-href="/foo"][up-target=".target"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(true)
+
+      it 'returns false if the given link will be handled by the browser', ->
+        $link = affix('a[href="/foo"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(false)
+
+      it 'returns false if the given link will be handled by Rails UJS', ->
+        $link = affix('a[href="/foo"][data-method="put"]')
+        up.hello $link
+        expect(up.link.isFollowable($link)).toBe(false)
+
   describe 'unobtrusive behavior', ->
 
     describe 'a[up-target]', ->
 
-      it 'does not follow a form with up-target attribute (bugfix)', ->
+      it 'does not follow a form with up-target attribute (bugfix)', asyncSpec (next) ->
         $form = affix('form[up-target]')
         up.hello($form)
-        followSpy = up.link.knife.mock('follow').and.returnValue(u.resolvedPromise())
+        followSpy = up.link.knife.mock('defaultFollow').and.returnValue(Promise.resolve())
         Trigger.clickSequence($form)
-        expect(followSpy).not.toHaveBeenCalled()
+
+        next =>
+          expect(followSpy).not.toHaveBeenCalled()
 
       describeCapability 'canPushState', ->
 
-        it 'adds a history entry', ->
+        it 'adds a history entry', asyncSpec (next) ->
+          up.history.config.enabled = true
+
           affix('.target')
           $link = affix('a[href="/path"][up-target=".target"]')
           Trigger.clickSequence($link)
-          @respondWith('<div class="target">new text</div>')
-          expect($('.target')).toHaveText('new text')
-          expect(location.pathname).toEqual('/path')
 
-        it 'respects a X-Up-Location header that the server sends in case of a redirect', ->
+          next =>
+            @respondWith('<div class="target">new text</div>')
+
+          next =>
+            expect($('.target')).toHaveText('new text')
+            expect(location.pathname).toEqual('/path')
+
+        it 'respects a X-Up-Location header that the server sends in case of a redirect', asyncSpec (next) ->
+          up.history.config.enabled = true
+
           affix('.target')
           $link = affix('a[href="/path"][up-target=".target"]')
           Trigger.clickSequence($link)
-          @respondWith
-            responseText: '<div class="target">new text</div>'
-            responseHeaders: { 'X-Up-Location': '/other/path' }
-          expect($('.target')).toHaveText('new text')
-          expect(location.pathname).toEqual('/other/path')
+
+          next =>
+            @respondWith
+              responseText: '<div class="target">new text</div>'
+              responseHeaders: { 'X-Up-Location': '/other/path' }
+
+          next =>
+            expect($('.target')).toHaveText('new text')
+            expect(location.pathname).toEqual('/other/path')
 
         describe 'choice of target layer', ->
 
           beforeEach ->
             up.motion.config.enabled = false
 
-          it 'prefers to update a container in the same layer as the clicked link', (done) ->
+          it 'prefers to update a container in the same layer as the clicked link', asyncSpec (next) ->
             affix('.document').affix('.target').text('old document text')
             up.modal.extract('.target', "<div class='target'>old modal text</div>")
 
-            u.nextFrame =>
+            next =>
               expect($('.document .target')).toHaveText('old document text')
               expect($('.up-modal .target')).toHaveText('old modal text')
 
               $linkInModal = $('.up-modal').affix('a[href="/bar"][up-target=".target"]')
               Trigger.clickSequence($linkInModal)
 
-              u.nextFrame =>
-                @respondWith '<div class="target">new text from modal link</div>'
-
-                expect($('.document .target')).toHaveText('old document text')
-                expect($('.up-modal .target')).toHaveText('new text from modal link')
+            next =>
+              @respondWith '<div class="target">new text from modal link</div>'
 
-                done()
+            next =>
+              expect($('.document .target')).toHaveText('old document text')
+              expect($('.up-modal .target')).toHaveText('new text from modal link')
 
           describe 'with [up-layer] modifier', ->
 
-            it 'allows to name a layer for the update', (done) ->
+            it 'allows to name a layer for the update', asyncSpec (next) ->
               affix('.document').affix('.target').text('old document text')
               up.modal.extract('.target', "<div class='target'>old modal text</div>", sticky: true)
 
-              u.nextFrame =>
+              next =>
                 expect($('.document .target')).toHaveText('old document text')
                 expect($('.up-modal .target')).toHaveText('old modal text')
 
                 $linkInModal = $('.up-modal').affix('a[href="/bar"][up-target=".target"][up-layer="page"]')
                 Trigger.clickSequence($linkInModal)
 
-                u.nextFrame =>
-                  @respondWith '<div class="target">new text from modal link</div>'
-
-                  expect($('.document .target')).toHaveText('new text from modal link')
-                  expect($('.up-modal .target')).toHaveText('old modal text')
+              next =>
+                @respondWith '<div class="target">new text from modal link</div>'
 
-                  done()
+              next =>
+                expect($('.document .target')).toHaveText('new text from modal link')
+                expect($('.up-modal .target')).toHaveText('old modal text')
 
-            it 'ignores [up-layer] if the server responds with a non-200 status code', (done) ->
+            it 'ignores [up-layer] if the server responds with a non-200 status code', asyncSpec (next) ->
               affix('.document').affix('.target').text('old document text')
               up.modal.extract('.target', "<div class='target'>old modal text</div>", sticky: true)
 
-              u.nextFrame =>
+              next =>
                 expect($('.document .target')).toHaveText('old document text')
                 expect($('.up-modal .target')).toHaveText('old modal text')
 
                 $linkInModal = $('.up-modal').affix('a[href="/bar"][up-target=".target"][up-fail-target=".target"][up-layer="page"]')
                 Trigger.clickSequence($linkInModal)
 
-                u.nextFrame =>
-                  @respondWith
-                    responseText: '<div class="target">new failure text from modal link</div>'
-                    status: 500
-
-                  expect($('.document .target')).toHaveText('old document text')
-                  expect($('.up-modal .target')).toHaveText('new failure text from modal link')
+              next =>
+                @respondWith
+                  responseText: '<div class="target">new failure text from modal link</div>'
+                  status: 500
 
-                  done()
+              next =>
+                expect($('.document .target')).toHaveText('old document text')
+                expect($('.up-modal .target')).toHaveText('new failure text from modal link')
 
-            it 'allows to name a layer for a non-200 response using an [up-fail-layer] modifier', (done) ->
+            it 'allows to name a layer for a non-200 response using an [up-fail-layer] modifier', asyncSpec (next) ->
               affix('.document').affix('.target').text('old document text')
               up.modal.extract('.target', "<div class='target'>old modal text</div>", sticky: true)
 
-              u.nextFrame =>
+              next =>
                 expect($('.document .target')).toHaveText('old document text')
                 expect($('.up-modal .target')).toHaveText('old modal text')
 
                 $linkInModal = $('.up-modal').affix('a[href="/bar"][up-target=".target"][up-fail-target=".target"][up-fail-layer="page"]')
                 Trigger.clickSequence($linkInModal)
 
-                u.nextFrame =>
-                  @respondWith
-                    responseText: '<div class="target">new failure text from modal link</div>'
-                    status: 500
-
-                  expect($('.document .target')).toHaveText('new failure text from modal link')
-                  expect($('.up-modal .target')).toHaveText('old modal text')
+              next =>
+                @respondWith
+                  responseText: '<div class="target">new failure text from modal link</div>'
+                  status: 500
 
-                  done()
+              next =>
+                expect($('.document .target')).toHaveText('new failure text from modal link')
+                expect($('.up-modal .target')).toHaveText('old modal text')
 
         describe 'with [up-fail-target] modifier', ->
 
@@ -459,145 +587,161 @@ describe 'up.link', ->
             affix('.failure-target').text('old failure text')
             @$link = affix('a[href="/path"][up-target=".success-target"][up-fail-target=".failure-target"]')
 
-          it 'uses the [up-fail-target] selector for a failed response', (done) ->
+          it 'uses the [up-fail-target] selector for a failed response', asyncSpec (next) ->
             Trigger.clickSequence(@$link)
-            u.nextFrame =>
+
+            next =>
               @respondWith('<div class="failure-target">new failure text</div>', status: 500)
-              u.nextFrame =>
-                expect($('.success-target')).toHaveText('old success text')
-                expect($('.failure-target')).toHaveText('new failure text')
-                done()
 
-          it 'uses the [up-target] selector for a successful response', (done) ->
+            next =>
+              expect($('.success-target')).toHaveText('old success text')
+              expect($('.failure-target')).toHaveText('new failure text')
+
+          it 'uses the [up-target] selector for a successful response', asyncSpec (next) ->
             Trigger.clickSequence(@$link)
-            u.nextFrame =>
+
+            next =>
               @respondWith('<div class="success-target">new success text</div>', status: 200)
-              u.nextFrame =>
-                expect($('.success-target')).toHaveText('new success text')
-                expect($('.failure-target')).toHaveText('old failure text')
-                done()
+
+            next =>
+              expect($('.success-target')).toHaveText('new success text')
+              expect($('.failure-target')).toHaveText('old failure text')
 
         describe 'with [up-transition] modifier', ->
 
-          it 'morphs between the old and new target element', (done) ->
+          it 'morphs between the old and new target element', asyncSpec (next) ->
             affix('.target.old')
             $link = affix('a[href="/path"][up-target=".target"][up-transition="cross-fade"][up-duration="500"][up-easing="linear"]')
             Trigger.clickSequence($link)
-            @respondWith '<div class="target new">new text</div>'
-
-            $oldGhost = $('.target.old.up-ghost')
-            $newGhost = $('.target.new.up-ghost')
-            expect($oldGhost).toExist()
-            expect($newGhost).toExist()
-            expect(u.opacity($oldGhost)).toBeAround(1, 0.15)
-            expect(u.opacity($newGhost)).toBeAround(0, 0.15)
-            u.setTimer 250, ->
-              expect(u.opacity($oldGhost)).toBeAround(0.5, 0.15)
-              expect(u.opacity($newGhost)).toBeAround(0.5, 0.15)
-              done()
+
+            next =>
+              @respondWith '<div class="target new">new text</div>'
+
+            next =>
+              @$oldGhost = $('.target.old.up-ghost')
+              @$newGhost = $('.target.new.up-ghost')
+              expect(@$oldGhost).toExist()
+              expect(@$newGhost).toExist()
+              expect(u.opacity(@$oldGhost)).toBeAround(1, 0.15)
+              expect(u.opacity(@$newGhost)).toBeAround(0, 0.15)
+
+            next.after 250, =>
+              expect(u.opacity(@$oldGhost)).toBeAround(0.5, 0.15)
+              expect(u.opacity(@$newGhost)).toBeAround(0.5, 0.15)
 
         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', ->
+          it 'uses the fallback selector if the [up-target] CSS does not exist on the page', asyncSpec (next) ->
             affix('.fallback').text('old fallback')
             $link = affix('a[href="/path"][up-target=".target"][up-fallback=".fallback"]')
             Trigger.clickSequence($link)
-            u.nextFrame ->
+
+            next =>
               @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', ->
+            next =>
+              expect('.fallback').toHaveText('new fallback')
+
+          it 'ignores the fallback selector if the [up-target] CSS exists on the page', asyncSpec (next) ->
             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 ->
+
+            next =>
               @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"', ->
+            next =>
+              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"', asyncSpec (next) ->
+        up.history.config.enabled = true
+
         oldPathname = location.pathname
         affix('.target')
         $link = affix('a[href="/path"][up-target=".target"][up-history="false"]')
         Trigger.clickSequence($link)
-        @respondWith
-          responseText: '<div class="target">new text</div>'
-          responseHeaders: { 'X-Up-Location': '/other/path' }
-        expect($('.target')).toHaveText('new text')
-        expect(location.pathname).toEqual(oldPathname)
+
+        next =>
+          @respondWith
+            responseText: '<div class="target">new text</div>'
+            responseHeaders: { 'X-Up-Location': '/other/path' }
+
+        next =>
+          expect($('.target')).toHaveText('new text')
+          expect(location.pathname).toEqual(oldPathname)
 
     describe 'a[up-follow]', ->
 
       beforeEach ->
-        @$link = affix('a[href="/path"][up-follow]')
-        @followSpy = up.link.knife.mock('follow').and.returnValue(u.resolvedPromise())
-        @defaultSpy = up.link.knife.mock('allowDefault').and.callFake((event) -> event.preventDefault())
+        @$link = affix('a[href="/follow-path"][up-follow]')
+        @followSpy = up.link.knife.mock('defaultFollow').and.returnValue(Promise.resolve())
+        @defaultSpy = spyOn(up.link, 'allowDefault').and.callFake((event) -> event.preventDefault())
 
-      it "calls up.follow with the clicked link", ->
+      it "calls up.follow with the clicked link", asyncSpec (next) ->
         Trigger.click(@$link)
-        expect(@followSpy).toHaveBeenCalledWith(@$link)
+        next =>
+          expect(@followSpy).toHaveBeenCalledWith(@$link, {})
 
       # IE does not call JavaScript and always performs the default action on right clicks
-      unless navigator.userAgent.match(/Trident/)
-        it 'does nothing if the right mouse button is used', ->
+      unless AgentDetector.isIE() || AgentDetector.isEdge()
+        it 'does nothing if the right mouse button is used', asyncSpec (next) ->
           Trigger.click(@$link, button: 2)
-          expect(@followSpy).not.toHaveBeenCalled()
+          next => expect(@followSpy).not.toHaveBeenCalled()
 
-      it 'does nothing if shift is pressed during the click', ->
+      it 'does nothing if shift is pressed during the click', asyncSpec (next) ->
         Trigger.click(@$link, shiftKey: true)
-        expect(@followSpy).not.toHaveBeenCalled()
+        next => expect(@followSpy).not.toHaveBeenCalled()
 
-      it 'does nothing if ctrl is pressed during the click', ->
+      it 'does nothing if ctrl is pressed during the click', asyncSpec (next)->
         Trigger.click(@$link, ctrlKey: true)
-        expect(@followSpy).not.toHaveBeenCalled()
+        next => expect(@followSpy).not.toHaveBeenCalled()
 
-      it 'does nothing if meta is pressed during the click', ->
+      it 'does nothing if meta is pressed during the click', asyncSpec (next)->
         Trigger.click(@$link, metaKey: true)
-        expect(@followSpy).not.toHaveBeenCalled()
+        next => expect(@followSpy).not.toHaveBeenCalled()
 
       describe 'with [up-instant] modifier', ->
 
         beforeEach ->
           @$link.attr('up-instant', '')
 
-        it 'follows a link on mousedown (instead of on click)', ->
+        it 'follows a link on mousedown (instead of on click)', asyncSpec (next)->
           Trigger.mousedown(@$link)
-          expect(@followSpy.calls.mostRecent().args[0]).toEqual(@$link)
+          next => expect(@followSpy.calls.mostRecent().args[0]).toEqual(@$link)
 
-        it 'does nothing on mouseup', ->
+        it 'does nothing on mouseup', asyncSpec (next)->
           Trigger.mouseup(@$link)
-          expect(@followSpy).not.toHaveBeenCalled()
+          next => expect(@followSpy).not.toHaveBeenCalled()
 
-        it 'does nothing on click', ->
+        it 'does nothing on click', asyncSpec (next)->
           Trigger.click(@$link)
-          expect(@followSpy).not.toHaveBeenCalled()
+          next => expect(@followSpy).not.toHaveBeenCalled()
 
         # IE does not call JavaScript and always performs the default action on right clicks
-        unless navigator.userAgent.match(/Trident/)
-          it 'does nothing if the right mouse button is pressed down', ->
+        unless AgentDetector.isIE() || AgentDetector.isEdge()
+          it 'does nothing if the right mouse button is pressed down', asyncSpec (next)->
             Trigger.mousedown(@$link, button: 2)
-            expect(@followSpy).not.toHaveBeenCalled()
+            next => expect(@followSpy).not.toHaveBeenCalled()
 
-        it 'does nothing if shift is pressed during mousedown', ->
+        it 'does nothing if shift is pressed during mousedown', asyncSpec (next) ->
           Trigger.mousedown(@$link, shiftKey: true)
-          expect(@followSpy).not.toHaveBeenCalled()
+          next => expect(@followSpy).not.toHaveBeenCalled()
 
-        it 'does nothing if ctrl is pressed during mousedown', ->
+        it 'does nothing if ctrl is pressed during mousedown', asyncSpec (next) ->
           Trigger.mousedown(@$link, ctrlKey: true)
-          expect(@followSpy).not.toHaveBeenCalled()
+          next => expect(@followSpy).not.toHaveBeenCalled()
 
-        it 'does nothing if meta is pressed during mousedown', ->
+        it 'does nothing if meta is pressed during mousedown', asyncSpec (next) ->
           Trigger.mousedown(@$link, metaKey: true)
-          expect(@followSpy).not.toHaveBeenCalled()
+          next => expect(@followSpy).not.toHaveBeenCalled()
 
     describe '[up-dash]', ->
 
@@ -672,19 +816,21 @@ describe 'up.link', ->
         up.hello($area)
         expect($area.attr('up-follow')).toEqual('')
 
-      it 'can be used to enlarge the click area of a link', ->
+      it 'can be used to enlarge the click area of a link', asyncSpec (next) ->
         $area = affix('div[up-expand] a[href="/path"]')
         up.hello($area)
         spyOn(up, 'replace')
         Trigger.clickSequence($area)
-        expect(up.replace).toHaveBeenCalled()
+        next =>
+          expect(up.replace).toHaveBeenCalled()
 
-      it 'does not trigger multiple replaces when the user clicks on the expanded area of an up-instant link (bugfix)', ->
+      it 'does not trigger multiple replaces when the user clicks on the expanded area of an [up-instant] link (bugfix)', asyncSpec (next) ->
         $area = affix('div[up-expand] a[href="/path"][up-follow][up-instant]')
         up.hello($area)
         spyOn(up, 'replace')
         Trigger.clickSequence($area)
-        expect(up.replace.calls.count()).toEqual(1)
+        next =>
+          expect(up.replace.calls.count()).toEqual(1)
 
       it 'does not add an up-follow attribute if the expanded link is [up-dash] with a selector (bugfix)', ->
         $area = affix('div[up-expand] a[href="/path"][up-dash=".element"]')