unpoly-rails 0.20.0

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

@@ -0,0 +1,132 @@
+describe 'up.navigation', ->
+  
+  describe 'unobtrusive behavior', ->
+
+    it 'marks a link as .up-current if it links to the current URL', ->
+      spyOn(up.browser, 'url').and.returnValue('/foo')
+      $currentLink = up.hello(affix('a[href="/foo"]'))
+      $otherLink = up.hello(affix('a[href="/bar"]'))
+      expect($currentLink).toHaveClass('up-current')
+      expect($otherLink).not.toHaveClass('up-current')
+      
+    it 'marks any link as .up-current if its up-href attribute matches the current URL', ->
+      spyOn(up.browser, 'url').and.returnValue('/foo')
+      $currentLink = up.hello(affix('span[up-href="/foo"]'))
+      $otherLink = up.hello(affix('span[up-href="/bar"]'))
+      expect($currentLink).toHaveClass('up-current')
+      expect($otherLink).not.toHaveClass('up-current')
+
+    it 'marks any link as .up-current if any of its space-separated up-alias values matches the current URL', ->
+      spyOn(up.browser, 'url').and.returnValue('/foo')
+      $currentLink = up.hello(affix('span[up-alias="/aaa /foo /bbb"]'))
+      $otherLink = up.hello(affix('span[up-alias="/bar"]'))
+      expect($currentLink).toHaveClass('up-current')
+      expect($otherLink).not.toHaveClass('up-current')
+
+    it 'does not throw if the current location does not match an up-alias wildcard (bugfix)', ->
+      inserter = -> up.hello(affix('a[up-alias="/qqqq*"]'))
+      expect(inserter).not.toThrow()
+
+    it 'does not highlight a link to "#" (commonly used for JS-only buttons)', ->
+      $link = up.hello(affix('a[href="#"]'))
+      expect($link).not.toHaveClass('up-current')
+
+    it 'marks URL prefixes as .up-current if an up-alias value ends in *', ->
+      spyOn(up.browser, 'url').and.returnValue('/foo/123')
+      $currentLink = up.hello(affix('span[up-alias="/aaa /foo/* /bbb"]'))
+      $otherLink = up.hello(affix('span[up-alias="/bar"]'))
+      expect($currentLink).toHaveClass('up-current')
+      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']
+      spyOn(up.browser, 'url').and.returnValue('/foo')
+      $currentLink = up.hello(affix('a[href="/foo"]'))
+      expect($currentLink).toHaveClass('highlight up-current')
+
+    describeCapability 'canPushState', ->
+      
+      it 'marks a link as .up-current if it links to the current URL, but is missing a trailing slash', ->
+        $link = affix('a[href="/foo"][up-target=".main"]')
+        affix('.main')
+        $link.click()
+        @respondWith
+          responseHeaders: { 'X-Up-Location': '/foo/' }
+          responseText: '<div class="main">new-text</div>'
+        expect($link).toHaveClass('up-current')
+      
+      it 'marks a link as .up-current if it links to the current URL, but has an extra trailing slash', ->
+        $link = affix('a[href="/foo/"][up-target=".main"]')
+        affix('.main')
+        $link.click()
+        @respondWith
+          responseHeaders: { 'X-Up-Location': '/foo' }
+          responseText: '<div class="main">new-text</div>'
+        expect($link).toHaveClass('up-current')
+
+      it 'marks a link as .up-current if it links to an URL currently shown either within or below the modal', (done) ->
+        up.history.replace('/foo')
+        $backgroundLink = affix('a[href="/foo"]')
+        $modalLink = affix('a[href="/bar"][up-modal=".main"]')
+        $unrelatedLink = affix('a[href="/baz]')
+
+        Trigger.click($modalLink)
+        @respondWith('<div class="main">new-text</div>')
+        expect($backgroundLink).toHaveClass('up-current')
+        expect($modalLink).toHaveClass('up-current')
+        expect($unrelatedLink).not.toHaveClass('up-current')
+
+        up.modal.close().then ->
+          expect($backgroundLink).toHaveClass('up-current')
+          expect($modalLink).not.toHaveClass('up-current')
+          expect($unrelatedLink).not.toHaveClass('up-current')
+          done()
+
+      it 'marks a link as .up-current if it links to the URL currently either within or below the popup', (done) ->
+        up.history.replace('/foo')
+        $backgroundLink = affix('a[href="/foo"]')
+        $popupLink = affix('a[href="/bar"][up-popup=".main"]')
+        $unrelatedLink = affix('a[href="/baz]')
+
+        $popupLink.click()
+        @respondWith('<div class="main">new-text</div>')
+        expect($backgroundLink).toHaveClass('up-current')
+        expect($popupLink).toHaveClass('up-current')
+        expect($unrelatedLink).not.toHaveClass('up-current')
+
+        up.popup.close().then ->
+          expect($backgroundLink).toHaveClass('up-current')
+          expect($popupLink).not.toHaveClass('up-current')
+          expect($unrelatedLink).not.toHaveClass('up-current')
+          done()
+
+      it 'changes .up-current marks as the URL changes'
+        
+      it 'marks clicked links as .up-active until the request finishes', ->
+        $link = affix('a[href="/foo"][up-target=".main"]')
+        affix('.main')
+        $link.click()
+        expect($link).toHaveClass('up-active')
+        @respondWith('<div class="main">new-text</div>')
+        expect($link).not.toHaveClass('up-active')
+        expect($link).toHaveClass('up-current')
+        
+      it 'marks links with [up-instant] on mousedown as .up-active until the request finishes', ->
+        $link = affix('a[href="/foo"][up-instant][up-target=".main"]')
+        affix('.main')
+        Trigger.mousedown($link)
+        expect($link).toHaveClass('up-active')
+        @respondWith('<div class="main">new-text</div>')
+        expect($link).not.toHaveClass('up-active')
+        expect($link).toHaveClass('up-current')
+    
+      it 'prefers to mark an enclosing [up-expand] click area', ->
+        $area = affix('div[up-expand] a[href="/foo"][up-target=".main"]')
+        up.hello($area)
+        $link = $area.find('a')
+        affix('.main')
+        $link.click()
+        expect($area).toHaveClass('up-active')
+        @respondWith('<div class="main">new-text</div>')
+        expect($area).toHaveClass('up-current')
+

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

@@ -0,0 +1,220 @@
+describe 'up.popup', ->
+
+  u = up.util
+
+  describe 'Javascript functions', ->
+
+    describe 'up.popup.attach', ->
+
+      it "loads this link's destination in a popup when clicked", ->
+        $link = affix('a[href="/path/to"][up-popup=".middle"]').text('link')
+        $link.css
+          position: 'fixed'
+          left: '100px'
+          top: '50px'
+
+        up.popup.attach($link)
+
+        expect(@lastRequest().url).toMatch /\/path\/to$/
+        @respondWith """
+          <div class="before">new-before</div>
+          <div class="middle">new-middle</div>
+          <div class="after">new-after</div>
+          """
+
+        $popup = $('.up-popup')
+
+        expect($popup).toExist()
+        expect($popup.find('.middle')).toHaveText('new-middle')
+        expect($popup.find('.before')).not.toExist()
+        expect($popup.find('.after')).not.toExist()
+
+        popupDims = u.measure($popup, full: true)
+        linkDims = u.measure($link, full: true)
+
+        expect(popupDims.right).toBeAround(linkDims.right, 1)
+        expect(popupDims.top).toBeAround(linkDims.top + linkDims.height, 1)
+
+      it 'does not explode if the popup was closed before the response was received', ->
+        $span = affix('span')
+        up.popup.attach($span, url: '/foo', target: '.container')
+        up.popup.close()
+        respond = => @respondWith('<div class="container">text</div>')
+        expect(respond).not.toThrowError()
+        expect($('.up-error')).not.toExist()
+
+    describe 'up.popup.coveredUrl', ->
+
+      describeCapability 'canPushState', ->
+
+        it 'returns the URL behind the popup', (done) ->
+          up.history.replace('/foo')
+          expect(up.popup.coveredUrl()).toBeUndefined()
+
+          $popupLink = affix('a[href="/bar"][up-popup=".container"]')
+          $popupLink.click()
+          @respondWith('<div class="container">text</div>')
+          expect(up.popup.coveredUrl()).toEndWith('/foo')
+          up.popup.close().then ->
+            expect(up.popup.coveredUrl()).toBeUndefined()
+            done()
+
+    describe 'up.popup.close', ->
+
+      it 'should have tests'
+
+    describe 'up.popup.source', ->
+
+      it 'should have tests'
+
+  describe 'unobtrusive behavior', ->
+
+    describe 'a[up-popup]', ->
+
+      beforeEach ->
+        @$link = affix('a[href="/path"][up-popup=".target"]')
+        @attachSpy = up.popup.knife.mock('attach')
+        @defaultSpy = up.link.knife.mock('allowDefault').and.callFake((event) -> event.preventDefault())
+
+      it 'opens the clicked link in a popup', ->
+        Trigger.click(@$link)
+        expect(@attachSpy).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', ->
+          Trigger.click(@$link, button: 2)
+          expect(@attachSpy).not.toHaveBeenCalled()
+
+      it 'does nothing if shift is pressed during the click', ->
+        Trigger.click(@$link, shiftKey: true)
+        expect(@attachSpy).not.toHaveBeenCalled()
+
+      it 'does nothing if ctrl is pressed during the click', ->
+        Trigger.click(@$link, ctrlKey: true)
+        expect(@attachSpy).not.toHaveBeenCalled()
+
+      it 'does nothing if meta is pressed during the click', ->
+        Trigger.click(@$link, metaKey: true)
+        expect(@attachSpy).not.toHaveBeenCalled()
+
+      describe 'with [up-instant] modifier', ->
+
+        beforeEach ->
+          @$link.attr('up-instant', '')
+
+        it 'opens the modal on mousedown (instead of on click)', ->
+          Trigger.mousedown(@$link)
+          expect(@attachSpy.calls.mostRecent().args[0]).toEqual(@$link)
+
+        it 'does nothing on mouseup', ->
+          Trigger.mouseup(@$link)
+          expect(@attachSpy).not.toHaveBeenCalled()
+
+        it 'does nothing on click', ->
+          Trigger.click(@$link)
+          expect(@attachSpy).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', ->
+            Trigger.mousedown(@$link, button: 2)
+            expect(@attachSpy).not.toHaveBeenCalled()
+
+        it 'does nothing if shift is pressed during mousedown', ->
+          Trigger.mousedown(@$link, shiftKey: true)
+          expect(@attachSpy).not.toHaveBeenCalled()
+
+        it 'does nothing if ctrl is pressed during mousedown', ->
+          Trigger.mousedown(@$link, ctrlKey: true)
+          expect(@attachSpy).not.toHaveBeenCalled()
+
+        it 'does nothing if meta is pressed during mousedown', ->
+          Trigger.mousedown(@$link, metaKey: true)
+          expect(@attachSpy).not.toHaveBeenCalled()
+
+    describe '[up-close]', ->
+
+      describe 'when clicked inside a popup', ->
+
+        it 'closes the open popup and prevents the default action', ->
+          $popup = affix('.up-popup')
+          $link = $popup.affix('a[up-close]') # link is within the popup
+          up.hello($link)
+          wasDefaultPrevented = false
+          wasClosed = false
+          up.on 'click', 'a[up-close]', (event) ->
+            wasDefaultPrevented = event.isDefaultPrevented()
+            true # the line above might return false and cancel propagation / prevent default
+          up.on 'up:popup:close', ->
+            wasClosed = true
+          $link.click()
+          expect(wasClosed).toBe(true)
+          expect(wasDefaultPrevented).toBe(true)
+
+      describe 'when no popup is open', ->
+
+        it 'does neither close the popup nor prevent the default action', ->
+          $link = affix('a[up-close]') # link is outside the popup
+          up.hello($link)
+          wasDefaultPrevented = false
+          wasClosed = false
+          up.on 'click', 'a[up-close]', (event) ->
+            wasDefaultPrevented = event.isDefaultPrevented()
+            true # the line above might return false and cancel propagation / prevent default
+          up.on 'up:popup:close', ->
+            wasClosed = true
+          $link.click()
+          expect(wasClosed).toBe(false)
+          expect(wasDefaultPrevented).toBe(false)
+
+    describe 'when replacing content', ->
+
+      beforeEach ->
+        up.motion.config.enabled = false
+
+      it 'prefers to replace a selector within the popup', ->
+        $outside = affix('.foo').text('old outside')
+        $link = affix('.link')
+        up.popup.attach($link, href: '/path', target: '.foo')
+        @respondWith("<div class='foo'>old inside</div>")
+        up.extract('.foo', "<div class='foo'>new text</div>")
+        expect($outside).toBeInDOM()
+        expect($outside).toHaveText('old outside')
+        expect($('.up-popup')).toHaveText('new text')
+
+      it 'auto-closes the popup when a replacement from inside the popup affects a selector behind the popup', ->
+        affix('.outside').text('old outside')
+        $link = affix('.link')
+        up.popup.attach($link, href: '/path', target: '.inside')
+        @respondWith("<div class='inside'>old inside</div>")
+        up.extract('.outside', "<div class='outside'>new outside</div>", origin: $('.inside'))
+        expect($('.outside')).toHaveText('new outside')
+        expect($('.up-popup')).not.toExist()
+
+      it 'does not auto-close the popup when a replacement from inside the popup affects a selector inside the popup', ->
+        affix('.outside').text('old outside')
+        $link = affix('.link')
+        up.popup.attach($link, href: '/path', target: '.inside')
+        @respondWith("<div class='inside'>old inside</div>")
+        up.extract('.inside', "<div class='inside'>new inside</div>", origin: $('.inside'))
+        expect($('.inside')).toHaveText('new inside')
+        expect($('.up-popup')).toExist()
+
+      it 'does not auto-close the popup when a replacement from outside the popup affects a selector outside the popup', ->
+        affix('.outside').text('old outside')
+        $link = affix('.link')
+        up.popup.attach($link, href: '/path', target: '.inside')
+        @respondWith("<div class='inside'>old inside</div>")
+        up.extract('.outside', "<div class='outside'>new outside</div>", origin: $('.outside'))
+        expect($('.outside')).toHaveText('new outside')
+        expect($('.up-popup')).toExist()
+
+      it 'does not auto-close the popup when a replacement from outside the popup affects a selector inside the popup', ->
+        affix('.outside').text('old outside')
+        $link = affix('.link')
+        up.popup.attach($link, href: '/path', target: '.inside')
+        @respondWith("<div class='inside'>old inside</div>")
+        up.extract('.inside', "<div class='inside'>new inside</div>", origin: $('.outside'))
+        expect($('.inside')).toHaveText('new inside')
+        expect($('.up-popup')).toExist()

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

@@ -0,0 +1,371 @@
+describe 'up.proxy', ->
+
+  u = up.util
+
+  describe 'Javascript functions', ->
+
+    beforeEach ->
+      jasmine.clock().install()
+      jasmine.clock().mockDate()
+
+    describe 'up.ajax', ->
+
+      it 'caches server responses for 5 minutes', ->
+        responses = []
+
+        # Send the same request for the same path, 3 minutes apart
+        up.ajax(url: '/foo').then (data) -> responses.push(data)
+        jasmine.clock().tick(3 * 60 * 1000)
+        up.ajax(url: '/foo').then (data) -> responses.push(data)
+
+        # See that only a single network request was triggered
+        expect(jasmine.Ajax.requests.count()).toEqual(1)
+        expect(responses).toEqual([])
+
+        @respondWith('foo')
+
+        # See that both requests have been fulfilled by the same response
+        expect(responses).toEqual(['foo', 'foo'])
+
+        # Send another request after another 3 minutes
+        # The clock is now a total of 6 minutes after the first request,
+        # exceeding the cache's retention time of 5 minutes.
+        jasmine.clock().tick(3 * 60 * 1000)
+        up.ajax(url: '/foo').then (data) -> responses.push(data)
+
+        # See that we have triggered a second request
+        expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+        @respondWith('bar')
+
+        expect(responses).toEqual(['foo', 'foo', 'bar'])
+
+      it "doesn't reuse responses when asked for the same path, but different selectors", ->
+        up.ajax(url: '/path', target: '.a')
+        up.ajax(url: '/path', target: '.b')
+        expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+      it "reuses a response for an 'html' selector when asked for the same path and any other selector", ->
+        up.ajax(url: '/path', target: 'html')
+        up.ajax(url: '/path', target: 'body')
+        up.ajax(url: '/path', target: 'p')
+        up.ajax(url: '/path', target: '.klass')
+        expect(jasmine.Ajax.requests.count()).toEqual(1)
+
+      it "reuses a response for a 'body' selector when asked for the same path and any other selector other than 'html'", ->
+        up.ajax(url: '/path', target: 'body')
+        up.ajax(url: '/path', target: 'p')
+        up.ajax(url: '/path', target: '.klass')
+        expect(jasmine.Ajax.requests.count()).toEqual(1)
+
+      it "doesn't reuse a response for a 'body' selector when asked for the same path but an 'html' selector", ->
+        up.ajax(url: '/path', target: 'body')
+        up.ajax(url: '/path', target: 'html')
+        expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+      it "doesn't reuse responses for different paths", ->
+        up.ajax(url: '/foo')
+        up.ajax(url: '/bar')
+        expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+      u.each ['GET', 'HEAD', 'OPTIONS'], (method) ->
+
+        it "caches #{method} requests", ->
+          u.times 2, -> up.ajax(url: '/foo', method: method)
+          expect(jasmine.Ajax.requests.count()).toEqual(1)
+
+        it "does not cache #{method} requests with cache: false option", ->
+          u.times 2, -> up.ajax(url: '/foo', method: method, cache: false)
+          expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+      u.each ['POST', 'PUT', 'DELETE'], (method) ->
+
+        it "does not cache #{method} requests", ->
+          u.times 2, -> up.ajax(url: '/foo', method: method)
+          expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+        it "caches #{method} requests with cache: true option", ->
+          u.times 2, -> up.ajax(url: '/foo', method: method, cache: true)
+          expect(jasmine.Ajax.requests.count()).toEqual(1)
+
+      it 'does not cache responses with a non-200 status code', ->
+        # Send the same request for the same path, 3 minutes apart
+        up.ajax(url: '/foo')
+
+        @respondWith
+          status: 500
+          contentType: 'text/html'
+          responseText: 'foo'
+
+        up.ajax(url: '/foo')
+
+        expect(jasmine.Ajax.requests.count()).toEqual(2)
+
+      describe 'with config.wrapMethods set', ->
+
+        it 'should be set by default', ->
+          expect(up.proxy.config.wrapMethods).toBePresent()
+
+#        beforeEach ->
+#          @oldWrapMethod = up.proxy.config.wrapMethod
+#          up.proxy.config.wrapMethod = true
+#
+#        afterEach ->
+#          up.proxy.config.wrapMethod = @oldWrapMetod
+
+        u.each ['GET', 'POST', 'HEAD', 'OPTIONS'], (method) ->
+
+          it "does not change the method of a #{method} request", ->
+            up.ajax(url: '/foo', method: method)
+            request = @lastRequest()
+            expect(request.method).toEqual(method)
+            expect(request.data()['_method']).toBeUndefined()
+
+        u.each ['PUT', 'PATCH', 'DELETE'], (method) ->
+
+          it "turns a #{method} request into a POST request and sends the actual method as a { _method } param", ->
+            up.ajax(url: '/foo', method: method)
+            request = @lastRequest()
+            expect(request.method).toEqual('POST')
+            expect(request.data()['_method']).toEqual([method])
+
+      describe 'with config.maxRequests set', ->
+
+        beforeEach ->
+          @oldMaxRequests = up.proxy.config.maxRequests
+          up.proxy.config.maxRequests = 1
+
+        afterEach ->
+          up.proxy.config.maxRequests = @oldMaxRequests
+
+        it 'limits the number of concurrent requests', ->
+          responses = []
+          up.ajax(url: '/foo').then (html) -> responses.push(html)
+          up.ajax(url: '/bar').then (html) -> responses.push(html)
+          expect(jasmine.Ajax.requests.count()).toEqual(1) # only one request was made
+          @respondWith('first response', request: jasmine.Ajax.requests.at(0))
+          expect(responses).toEqual ['first response']
+          expect(jasmine.Ajax.requests.count()).toEqual(2) # a second request was made
+          @respondWith('second response', request: jasmine.Ajax.requests.at(1))
+          expect(responses).toEqual ['first response', 'second response']
+
+#        it 'considers preloading links for the request limit', ->
+#          up.ajax(url: '/foo', preload: true)
+#          up.ajax(url: '/bar')
+#          expect(jasmine.Ajax.requests.count()).toEqual(1)
+
+      describe 'events', ->
+        
+        beforeEach ->
+          up.proxy.config.busyDelay = 0
+          @events = []
+          u.each ['up:proxy:load', 'up:proxy:received', 'up:proxy:busy', 'up:proxy:idle'], (eventName) =>
+            up.on eventName, =>
+              @events.push eventName
+
+        it 'emits an up:proxy:busy event once the proxy started loading, and up:proxy:idle if it is done loading', ->
+  
+          up.ajax(url: '/foo')
+  
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy'
+          ])
+  
+          up.ajax(url: '/bar')
+  
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy',
+            'up:proxy:load'
+          ])
+  
+          jasmine.Ajax.requests.at(0).respondWith
+            status: 200
+            contentType: 'text/html'
+            responseText: 'foo'
+  
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy',
+            'up:proxy:load',
+            'up:proxy:received'
+          ])
+  
+          jasmine.Ajax.requests.at(1).respondWith
+            status: 200
+            contentType: 'text/html'
+            responseText: 'bar'
+  
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy',
+            'up:proxy:load',
+            'up:proxy:received',
+            'up:proxy:received',
+            'up:proxy:idle'
+          ])
+  
+        it 'does not emit an up:proxy:busy event if preloading', ->
+
+          # A request for preloading preloading purposes
+          # doesn't make us busy.
+          up.ajax(url: '/foo', preload: true)
+          expect(@events).toEqual([
+            'up:proxy:load'
+          ])
+          expect(up.proxy.busy()).toBe(false)
+
+          # The same request with preloading does make us busy.
+          up.ajax(url: '/foo')
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy'
+          ])
+          expect(up.proxy.busy()).toBe(true)
+
+          # The response resolves both promises and makes
+          # the proxy idle again.
+          jasmine.Ajax.requests.at(0).respondWith
+            status: 200
+            contentType: 'text/html'
+            responseText: 'foo'
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy',
+            'up:proxy:received',
+            'up:proxy:idle'
+          ])
+          expect(up.proxy.busy()).toBe(false)
+
+        it 'can delay the up:proxy:busy event to prevent flickering of spinners', ->
+          up.proxy.config.busyDelay = 100
+
+          up.ajax(url: '/foo')
+          expect(@events).toEqual([
+            'up:proxy:load'
+          ])
+
+          jasmine.clock().tick(50)
+          expect(@events).toEqual([
+            'up:proxy:load'
+          ])
+
+          jasmine.clock().tick(50)
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy'
+          ])
+
+          jasmine.Ajax.requests.at(0).respondWith
+            status: 200
+            contentType: 'text/html'
+            responseText: 'foo'
+
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy',
+            'up:proxy:received',
+            'up:proxy:idle'
+          ])
+
+        it 'does not emit up:proxy:idle if a delayed up:proxy:busy was never emitted due to a fast response', ->
+          up.proxy.config.busyDelay = 100
+
+          up.ajax(url: '/foo')
+          expect(@events).toEqual([
+            'up:proxy:load'
+          ])
+
+          jasmine.clock().tick(50)
+
+          jasmine.Ajax.requests.at(0).respondWith
+            status: 200
+            contentType: 'text/html'
+            responseText: 'foo'
+
+          jasmine.clock().tick(100)
+
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:received'
+          ])
+
+        it 'emits up:proxy:idle if a request returned but failed', ->
+
+          up.ajax(url: '/foo')
+
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy'
+          ])
+
+          jasmine.Ajax.requests.at(0).respondWith
+            status: 500
+            contentType: 'text/html'
+            responseText: 'something went wrong'
+
+          expect(@events).toEqual([
+            'up:proxy:load',
+            'up:proxy:busy',
+            'up:proxy:received',
+            'up:proxy:idle'
+          ])
+
+
+    describe 'up.proxy.preload', ->
+
+      describeCapability 'canPushState', ->
+
+        it "loads and caches the given link's destination", ->
+          $link = affix('a[href="/path"]')
+          up.proxy.preload($link)
+          expect(u.isPromise(up.proxy.get(url: '/path'))).toBe(true)
+
+        it "does not load a link whose method has side-effects", ->
+          $link = affix('a[href="/path"][data-method="post"]')
+          up.proxy.preload($link)
+          expect(up.proxy.get(url: '/path')).toBeUndefined()
+
+      describeFallback 'canPushState', ->
+
+        it "does nothing", ->
+          $link = affix('a[href="/path"]')
+          up.proxy.preload($link)
+          expect(jasmine.Ajax.requests.count()).toBe(0)
+
+    describe 'up.proxy.get', ->
+
+      it 'should have tests'
+
+    describe 'up.proxy.set', ->
+
+      it 'should have tests'
+
+    describe 'up.proxy.alias', ->
+
+      it 'uses an existing cache entry for another request (used in case of redirects)'
+
+    describe 'up.proxy.clear', ->
+
+      it 'removes all cache entries'
+
+  describe 'unobtrusive behavior', ->
+
+    describe '[up-preload]', ->
+
+      it 'preloads the link destination on mouseover, after a delay'
+
+      it 'triggers a separate AJAX request with a short cache expiry when hovered multiple times', (done) ->
+        up.proxy.config.cacheExpiry = 10
+        up.proxy.config.preloadDelay = 0
+        spyOn(up, 'follow')
+        $element = affix('a[href="/foo"][up-preload]')
+        Trigger.mouseover($element)
+        @setTimer 1, =>
+          expect(up.follow.calls.count()).toBe(1)
+          @setTimer 16, =>
+            Trigger.mouseover($element)
+            @setTimer 1, =>
+              expect(up.follow.calls.count()).toBe(2)
+              done()