cloudkit 0.9.1 → 0.10.0

data/test/helper.rb

@@ -4,50 +4,17 @@ require 'test/unit'
 require 'shoulda'
 require 'rexml/document'
 
-def auth_key; "cloudkit.user"; end
-def remote_user; "/cloudkit_users/abcdef"; end
+TEST_REMOTE_USER = '/cloudkit_users/abcdef'.freeze
+VALID_TEST_AUTH = {CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER}.freeze
 
 def echo_text(text)
-  lambda {|env| [200, {'Content-Type' => 'text/html'}, [text]]}
+  lambda {|env| [200, app_headers(text), [text]]}
 end
 
 def echo_env(key)
-  lambda {|env| [200, {'Content-Type' => 'text/html'}, [env[key] || '']]}
+  lambda {|env| [200, app_headers(env[key] || ''), [env[key] || '']]}
 end
 
-def auth
-  {auth_key => remote_user}
-end
-
-def plain_service
-  Rack::Builder.new do
-    use Rack::Lint
-    use Rack::Config do |env|
-      env['cloudkit.storage.uri'] = 'sqlite://service.db'
-    end
-    use CloudKit::Service, :collections => [:items, :things]
-    run echo_text('martino')
-  end
-end
-
-def authed_service
-  Rack::Builder.new do
-    use Rack::Lint
-    use Rack::Config do |env|
-      env['cloudkit.storage.uri'] = 'sqlite://service.db'
-      r = CloudKit::Request.new(env)
-      r.announce_auth('cloudkit.filter.oauth') # mock
-    end
-    use CloudKit::Service, :collections => [:items, :things]
-    run echo_text('martino')
-  end
-end
-
-def openid_app
-  Rack::Builder.new do
-    use Rack::Lint
-    use Rack::Session::Pool
-    use CloudKit::OpenIDFilter
-    run echo_env(auth_key)
-  end
+def app_headers(content)
+  {'Content-Type' => 'text/html', 'Content-Length' => content.length.to_s}
 end

data/test/oauth_filter_test.rb

@@ -1,10 +1,10 @@
 require 'helper'
 class OAuthFilterTest < Test::Unit::TestCase
 
-  context "An OAuthFilter" do  
+  context "An OAuthFilter" do
 
     setup do
-      @oauth_filtered_app = CloudKit::OAuthFilter.new(echo_env(auth_key))
+      @oauth_filtered_app = CloudKit::OAuthFilter.new(echo_env(CLOUDKIT_AUTH_KEY))
       token = JSON.generate(
         :secret          => 'pfkkdhi9sl3r4s00',
         :consumer_key    => 'dpf43f3p2l4k3l03',
@@ -28,9 +28,9 @@ class OAuthFilterTest < Test::Unit::TestCase
     end
 
     should "notify downstream nodes of its presence" do
-      app = CloudKit::OAuthFilter.new(echo_env('cloudkit.via'))
+      app = CloudKit::OAuthFilter.new(echo_env(CLOUDKIT_VIA))
       response = Rack::MockRequest.new(app).get('/')
-      assert_equal 'cloudkit.filter.oauth', response.body
+      assert_equal CLOUDKIT_OAUTH_FILTER_KEY, response.body
     end
 
     should "not allow a nonce/timestamp combination to appear twice" do
@@ -69,12 +69,12 @@ class OAuthFilterTest < Test::Unit::TestCase
 
       should "set the auth challenge for unauthorized requests" do
         app = CloudKit::OAuthFilter.new(
-          lambda {|env| [200, {}, [env['cloudkit.challenge']['WWW-Authenticate'] || '']]})
+          lambda {|env| [200, {}, [env[CLOUDKIT_AUTH_CHALLENGE]['WWW-Authenticate'] || '']]})
         response = Rack::MockRequest.new(app).get(
           '/items', 'HTTP_HOST' => 'example.org')
         assert_equal 'OAuth realm="http://example.org"', response.body
         app = CloudKit::OAuthFilter.new(
-          lambda {|env| [200, {}, [env['cloudkit.challenge']['Link'] || '']]})
+          lambda {|env| [200, {}, [env[CLOUDKIT_AUTH_CHALLENGE]['Link'] || '']]})
         response = Rack::MockRequest.new(app).get(
           '/items', 'HTTP_HOST' => 'example.org')
         assert_equal '<http://example.org/oauth/meta>; rel="http://oauth.net/discovery/1.0/rel/provider"',
@@ -186,7 +186,7 @@ class OAuthFilterTest < Test::Unit::TestCase
         response = get_request_token
         token, secret = extract_token(response)
         response = Rack::MockRequest.new(@oauth_filtered_app).get(
-          "/oauth/authorization?oauth_token=#{token}", auth)
+          "/oauth/authorization?oauth_token=#{token}", VALID_TEST_AUTH)
         assert_equal 200, response.status
       end
 
@@ -194,7 +194,7 @@ class OAuthFilterTest < Test::Unit::TestCase
         response = get_request_token
         token, secret = extract_token(response)
         response = Rack::MockRequest.new(@oauth_filtered_app).get(
-          "/oauth/authorization?oauth_token=fail", auth)
+          "/oauth/authorization?oauth_token=fail", VALID_TEST_AUTH)
         assert_equal 401, response.status
       end
 
@@ -202,7 +202,7 @@ class OAuthFilterTest < Test::Unit::TestCase
         response = get_request_token
         token, secret = extract_token(response)
         response = Rack::MockRequest.new(@oauth_filtered_app).put(
-          "/oauth/authorized_request_tokens/#{token}?submit=Approve", auth)
+          "/oauth/authorized_request_tokens/#{token}?submit=Approve", VALID_TEST_AUTH)
         assert_equal 200, response.status
         request_token = @store.get("/cloudkit_oauth_request_tokens/#{token}").parsed_content
         assert request_token['authorized_at']
@@ -213,7 +213,7 @@ class OAuthFilterTest < Test::Unit::TestCase
         response = get_request_token
         token, secret = extract_token(response)
         response = Rack::MockRequest.new(@oauth_filtered_app).put(
-          "/oauth/authorized_request_tokens/#{token}?submit=Deny", auth)
+          "/oauth/authorized_request_tokens/#{token}?submit=Deny", VALID_TEST_AUTH)
         assert_equal 200, response.status
         request_token = @store.get("/cloudkit_oauth_request_tokens/#{token}").parsed_content
         assert 410, response.status
@@ -232,10 +232,10 @@ class OAuthFilterTest < Test::Unit::TestCase
         response = get_request_token
         token, secret = extract_token(response)
         response = Rack::MockRequest.new(@oauth_filtered_app).put(
-          "/oauth/authorized_request_tokens/#{token}?submit=Approve", auth)
+          "/oauth/authorized_request_tokens/#{token}?submit=Approve", VALID_TEST_AUTH)
         assert_equal 200, response.status
         response = Rack::MockRequest.new(@oauth_filtered_app).put(
-          "/oauth/authorized_request_tokens/#{token}?submit=Approve", auth)
+          "/oauth/authorized_request_tokens/#{token}?submit=Approve", VALID_TEST_AUTH)
         assert_equal 401, response.status
       end
 
@@ -296,7 +296,7 @@ class OAuthFilterTest < Test::Unit::TestCase
     response = get_request_token
     token, secret = extract_token(response)
     response = Rack::MockRequest.new(@oauth_filtered_app).put(
-      "/oauth/authorized_request_tokens/#{token}", auth)
+      "/oauth/authorized_request_tokens/#{token}", VALID_TEST_AUTH)
     assert_equal 200, response.status
     pre_sign = Rack::Request.new(Rack::MockRequest.env_for(
       'http://photos.example.net/oauth/access_tokens',

data/test/openid_filter_test.rb

@@ -4,6 +4,12 @@ class OpenIDFilterTest < Test::Unit::TestCase
   context "An OpenIDFilter" do
 
     setup do
+      openid_app = Rack::Builder.new {
+        use Rack::Lint
+        use Rack::Session::Pool
+        use CloudKit::OpenIDFilter
+        run echo_env(CLOUDKIT_AUTH_KEY)
+      }
       @request = Rack::MockRequest.new(openid_app)
     end
 
@@ -22,31 +28,31 @@ class OpenIDFilterTest < Test::Unit::TestCase
       app = Rack::Builder.new do
         use Rack::Session::Pool
         use CloudKit::OpenIDFilter
-        run echo_env('cloudkit.via')
+        run echo_env(CLOUDKIT_VIA)
       end
       response = Rack::MockRequest.new(app).get('/')
-      assert_equal 'cloudkit.filter.openid', response.body
+      assert_equal CLOUDKIT_OPENID_FILTER_KEY, response.body
     end
 
     context "with upstream authorization middleware" do
 
       should "allow pass through if the auth env variable is populated" do
-        response = @request.get('/protected', auth)
+        response = @request.get('/protected', VALID_TEST_AUTH)
         assert_equal 200, response.status
-        assert_equal remote_user, response.body
+        assert_equal TEST_REMOTE_USER, response.body
       end
 
       should "return the auth challenge header" do
         response = @request.get('/protected',
-          'cloudkit.via' => 'cloudkit.filter.oauth',
-          'cloudkit.challenge' => {'WWW-Authenticate' => 'etc.'})
+          CLOUDKIT_VIA => CLOUDKIT_OAUTH_FILTER_KEY,
+          CLOUDKIT_AUTH_CHALLENGE => {'WWW-Authenticate' => 'etc.'})
         assert response['WWW-Authenticate']
       end
 
       should "return a 401 status if authorization is required" do
         response = @request.get('/protected',
-          'cloudkit.via' => 'cloudkit.filter.oauth',
-          'cloudkit.challenge' => {'WWW-Authenticate' => 'etc.'})
+          CLOUDKIT_VIA => CLOUDKIT_OAUTH_FILTER_KEY,
+          CLOUDKIT_AUTH_CHALLENGE => {'WWW-Authenticate' => 'etc.'})
         assert_equal 401, response.status
       end
     end

data/test/request_test.rb

@@ -68,13 +68,13 @@ class RequestTest < Test::Unit::TestCase
 
     should "announce the use of auth middleware" do
       request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
-      request.announce_auth('cloudkit.filter.oauth')
-      assert request.via.include?('cloudkit.filter.oauth')
+      request.announce_auth(CLOUDKIT_OAUTH_FILTER_KEY)
+      assert request.via.include?(CLOUDKIT_OAUTH_FILTER_KEY)
     end
 
     should "know if auth provided by upstream middleware" do
       request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
-      request.announce_auth('cloudkit.filter.oauth')
+      request.announce_auth(CLOUDKIT_OAUTH_FILTER_KEY)
       assert request.using_auth?
     end
 
@@ -82,7 +82,7 @@ class RequestTest < Test::Unit::TestCase
       request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
       assert_nil request.current_user
       request = CloudKit::Request.new(
-        Rack::MockRequest.env_for('/', 'cloudkit.user' => 'cecil'))
+        Rack::MockRequest.env_for('/', CLOUDKIT_AUTH_KEY => 'cecil'))
       assert request.current_user
       assert_equal 'cecil', request.current_user
     end
@@ -99,7 +99,7 @@ class RequestTest < Test::Unit::TestCase
       assert_equal '/login', request.login_url
       request = CloudKit::Request.new(
         Rack::MockRequest.env_for(
-          '/', 'cloudkit.filter.openid.url.login' => '/sessions'))
+          '/', CLOUDKIT_LOGIN_URL => '/sessions'))
       assert_equal '/sessions', request.login_url
     end
 
@@ -114,7 +114,7 @@ class RequestTest < Test::Unit::TestCase
       assert_equal '/logout', request.logout_url
       request = CloudKit::Request.new(
         Rack::MockRequest.env_for(
-          '/', 'cloudkit.filter.openid.url.logout' => '/sessions'))
+          '/', CLOUDKIT_LOGOUT_URL => '/sessions'))
       assert_equal '/sessions', request.logout_url
     end
 

data/test/service_test.rb

@@ -3,24 +3,19 @@ class ServiceTest < Test::Unit::TestCase
 
   context "A CloudKit::Service" do
 
-    setup do
-      @request = Rack::MockRequest.new(plain_service)
-    end
-
-    teardown do
-      FileUtils.rm_f('service.db')
-    end
-
     should "return a 501 for unimplemented methods" do
-      response = @request.request('TRACE', '/items')
+      app = Rack::Builder.new {
+        use Rack::Lint
+        use CloudKit::Service, :collections => [:items, :things]
+        run echo_text('martino')
+      }
+
+      response = Rack::MockRequest.new(app).request('TRACE', '/items')
       assert_equal 501, response.status
 
       # disable Rack::Lint so that an invalid HTTP method
       # can be tested
       app = Rack::Builder.new {
-        use Rack::Config do |env|
-          env['cloudkit.storage.uri'] = 'sqlite://service.db'
-        end
         use CloudKit::Service, :collections => [:items, :things]
         run echo_text('nothing')
       }
@@ -31,9 +26,16 @@ class ServiceTest < Test::Unit::TestCase
     context "using auth" do
 
       setup do
-        @store = CloudKit::Store.new(
-          :adapter     => CloudKit::SQLAdapter.new('sqlite://service.db'),
-          :collections => [:items, :things])
+        # mock an authenticated service in pieces
+        mock_auth = Proc.new { |env|
+          r = CloudKit::Request.new(env)
+          r.announce_auth(CLOUDKIT_OAUTH_FILTER_KEY)
+        }
+        inner_app = echo_text('martino')
+        service = CloudKit::Service.new(
+          inner_app, :collections => [:items, :things])
+        config = Rack::Config.new(service, &mock_auth)
+        authed_service = Rack::Lint.new(config)
         @request = Rack::MockRequest.new(authed_service)
       end
 
@@ -48,7 +50,7 @@ class ServiceTest < Test::Unit::TestCase
       end
 
       should "return a 500 if authentication is configured incorrectly" do
-        # simulate auth requirement without the auth_key being set by the
+        # simulate auth requirement without CLOUDKIT_AUTH_KEY being set by the
         # auth filter(s)
         response = @request.get('/items')
         assert_equal 500, response.status
@@ -57,7 +59,7 @@ class ServiceTest < Test::Unit::TestCase
       context "on GET /cloudkit-meta" do
 
         setup do
-          @response = @request.get('/cloudkit-meta', auth_key => remote_user)
+          @response = @request.get('/cloudkit-meta', VALID_TEST_AUTH)
         end
 
         should "be successful" do
@@ -87,11 +89,13 @@ class ServiceTest < Test::Unit::TestCase
         setup do
           3.times do |i|
             json = JSON.generate(:this => i.to_s)
-            @store.put("/items/#{i}", :json => json, :remote_user => remote_user)
+            @request.put("/items/#{i}", {:input => json}.merge(VALID_TEST_AUTH))
           end
           json = JSON.generate(:this => '4')
-          @store.put('/items/4', :json => json, :remote_user => 'someoneelse')
-          @response = @request.get('/items', auth_key => remote_user)
+          @request.put(
+            '/items/4', {:input => json}.merge(CLOUDKIT_AUTH_KEY => 'someoneelse'))
+          @response = @request.get(
+            '/items', {'HTTP_HOST' => 'example.org'}.merge(VALID_TEST_AUTH))
           @parsed_response = JSON.parse(@response.body)
         end
 
@@ -132,14 +136,14 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "accept a limit parameter" do
-          response = @request.get('/items?limit=2', auth_key => remote_user)
+          response = @request.get('/items?limit=2', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal ['/items/2', '/items/1'], parsed_response['uris']
           assert_equal 3, parsed_response['total']
         end
 
         should "accept an offset parameter" do
-          response = @request.get('/items?offset=1', auth_key => remote_user)
+          response = @request.get('/items?offset=1', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal ['/items/1', '/items/0'], parsed_response['uris']
           assert_equal 1, parsed_response['offset']
@@ -147,7 +151,7 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "accept combined limit and offset parameters" do
-          response = @request.get('/items?limit=1&offset=1', auth_key => remote_user)
+          response = @request.get('/items?limit=1&offset=1', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal ['/items/1'], parsed_response['uris']
           assert_equal 1, parsed_response['offset']
@@ -155,21 +159,117 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "return an empty list if no resources are found" do
-          response = @request.get('/things', auth_key => remote_user)
+          response = @request.get('/things', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal [], parsed_response['uris']
           assert_equal 0, parsed_response['total']
           assert_equal 0, parsed_response['offset']
         end
+
+        should "return a resolved link header" do
+          assert @response['Link']
+          assert @response['Link'].match("<http://example.org/items/_resolved>; rel=\"http://joncrosby.me/cloudkit/1.0/rel/resolved\"")
+        end
+      end
+
+      context "on GET /:collection/_resolved" do
+
+        setup do
+          3.times do |i|
+            json = JSON.generate(:this => i.to_s)
+            @request.put("/items/#{i}", {:input => json}.merge(VALID_TEST_AUTH))
+          end
+          json = JSON.generate(:this => '4')
+          @request.put(
+            '/items/4', {:input => json}.merge(CLOUDKIT_AUTH_KEY => 'someoneelse'))
+          @response = @request.get(
+            '/items/_resolved', {'HTTP_HOST' => 'example.org'}.merge(VALID_TEST_AUTH))
+          @parsed_response = JSON.parse(@response.body)
+        end
+
+        should "be successful" do
+          assert_equal 200, @response.status
+        end
+
+        should "return all owner-originated documents" do
+          assert_same_elements ['/items/0', '/items/1', '/items/2'],
+            @parsed_response['documents'].map{|d| d['uri']}
+        end
+
+        should "sort descending on last_modified date" do
+          assert_equal ['/items/2', '/items/1', '/items/0'],
+            @parsed_response['documents'].map{|d| d['uri']}
+        end
+
+        should "return the total number of documents" do
+          assert @parsed_response['total']
+          assert_equal 3, @parsed_response['total']
+        end
+
+        should "return the offset" do
+          assert @parsed_response['offset']
+          assert_equal 0, @parsed_response['offset']
+        end
+
+        should "return a Content-Type header" do
+          assert_equal 'application/json', @response['Content-Type']
+        end
+
+        should "return an ETag" do
+          assert @response['ETag']
+        end
+
+        should "return a Last-Modified date" do
+          assert @response['Last-Modified']
+        end
+
+        should "accept a limit parameter" do
+          response = @request.get('/items/_resolved?limit=2', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal ['/items/2', '/items/1'],
+            parsed_response['documents'].map{|d| d['uri']}
+          assert_equal 3, parsed_response['total']
+        end
+
+        should "accept an offset parameter" do
+          response = @request.get('/items/_resolved?offset=1', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal ['/items/1', '/items/0'],
+            parsed_response['documents'].map{|d| d['uri']}
+          assert_equal 1, parsed_response['offset']
+          assert_equal 3, parsed_response['total']
+        end
+
+        should "accept combined limit and offset parameters" do
+          response = @request.get('/items/_resolved?limit=1&offset=1', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal ['/items/1'],
+            parsed_response['documents'].map{|d| d['uri']}
+          assert_equal 1, parsed_response['offset']
+          assert_equal 3, parsed_response['total']
+        end
+
+        should "return an empty list if no documents are found" do
+          response = @request.get('/things/_resolved', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal [], parsed_response['documents']
+          assert_equal 0, parsed_response['total']
+          assert_equal 0, parsed_response['offset']
+        end
+
+        should "return an index link header" do
+          assert @response['Link']
+          assert @response['Link'].match("<http://example.org/items>; rel=\"index\"")
+        end
       end
 
       context "on GET /:collection/:id" do
 
         setup do
           json = JSON.generate(:this => 'that')
-          @store.put('/items/abc', :json => json, :remote_user => remote_user)
+          @request.put('/items/abc', {:input => json}.merge(VALID_TEST_AUTH))
           @response = @request.get(
-            '/items/abc', 'HTTP_HOST' => 'example.org', auth_key => remote_user)
+            '/items/abc', {'HTTP_HOST' => 'example.org'}.merge(VALID_TEST_AUTH))
         end
 
         should "be successful" do
@@ -182,7 +282,7 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "return a 404 if a document does not exist" do
-          response = @request.get('/items/nothing', auth_key => remote_user)
+          response = @request.get('/items/nothing', VALID_TEST_AUTH)
           assert_equal 404, response.status
         end
 
@@ -199,7 +299,7 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "not return documents for unauthorized users" do
-          response = @request.get('/items/abc', auth_key => 'bogus')
+          response = @request.get('/items/abc', CLOUDKIT_AUTH_KEY => 'bogus')
           assert_equal 404, response.status
         end
 
@@ -215,12 +315,13 @@ class ServiceTest < Test::Unit::TestCase
           @etags = []
           4.times do |i|
             json = JSON.generate(:this => i)
-            options = {:json => json, :remote_user => remote_user}
-            options.filter_merge!(:etag => @etags.try(:last))
-            result = @store.put('/items/abc', options)
-            @etags << result.parsed_content['etag']
+            options = {:input => json}.merge(VALID_TEST_AUTH)
+            options.filter_merge!('HTTP_IF_MATCH' => @etags.try(:last))
+            result = @request.put('/items/abc', options)
+            @etags << JSON.parse(result.body)['etag']
           end
-          @response = @request.get('/items/abc/versions', auth_key => remote_user)
+          @response = @request.get(
+            '/items/abc/versions', {'HTTP_HOST' => 'example.org'}.merge(VALID_TEST_AUTH))
           @parsed_response = JSON.parse(@response.body)
         end
 
@@ -229,8 +330,8 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "be successful even if the current resource has been deleted" do
-          @store.delete('/items/abc', :etag => @etags.last, :remote_user => remote_user)
-          response = @request.get('/items/abc/versions', auth_key => remote_user)
+          @request.delete('/items/abc', {'HTTP_IF_MATCH' => @etags.last}.merge(VALID_TEST_AUTH))
+          response = @request.get('/items/abc/versions', VALID_TEST_AUTH)
           assert_equal 200, @response.status
           parsed_response = JSON.parse(response.body)
           assert_equal 4, parsed_response['uris'].size
@@ -243,18 +344,20 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "return a 404 if the resource does not exist" do
-          response = @request.get('/items/nothing/versions', auth_key => remote_user)
+          response = @request.get('/items/nothing/versions', VALID_TEST_AUTH)
           assert_equal 404, response.status
         end
 
         should "return a 404 for non-owner-originated requests" do
-          response = @request.get('/items/abc/versions', auth_key => 'someoneelse')
+          response = @request.get(
+            '/items/abc/versions', CLOUDKIT_AUTH_KEY => 'someoneelse')
           assert_equal 404, response.status
         end
 
         should "sort descending on last_modified date" do
-          assert_equal ['/items/abc'].concat(@etags[0..-2].reverse.map{|e| "/items/abc/versions/#{e}"}),
-            @parsed_response['uris']
+          assert_equal(
+            ['/items/abc'].concat(@etags[0..-2].reverse.map{|e| "/items/abc/versions/#{e}"}),
+            @parsed_response['uris'])
         end
 
         should "return the total number of uris" do
@@ -280,7 +383,7 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "accept a limit parameter" do
-          response = @request.get('/items/abc/versions?limit=2', auth_key => remote_user)
+          response = @request.get('/items/abc/versions?limit=2', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal ['/items/abc', "/items/abc/versions/#{@etags[-2]}"],
             parsed_response['uris']
@@ -288,7 +391,7 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "accept an offset parameter" do
-          response = @request.get('/items/abc/versions?offset=1', auth_key => remote_user)
+          response = @request.get('/items/abc/versions?offset=1', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal @etags.reverse[1..-1].map{|e| "/items/abc/versions/#{e}"},
             parsed_response['uris']
@@ -297,12 +400,125 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "accept combined limit and offset parameters" do
-          response = @request.get('/items/abc/versions?limit=1&offset=1', auth_key => remote_user)
+          response = @request.get('/items/abc/versions?limit=1&offset=1', VALID_TEST_AUTH)
           parsed_response = JSON.parse(response.body)
           assert_equal ["/items/abc/versions/#{@etags[-2]}"], parsed_response['uris']
           assert_equal 1, parsed_response['offset']
           assert_equal 4, parsed_response['total']
         end
+
+        should "return a resolved link header" do
+          assert @response['Link']
+          assert @response['Link'].match("<http://example.org/items/abc/versions/_resolved>; rel=\"http://joncrosby.me/cloudkit/1.0/rel/resolved\"")
+        end
+      end
+
+      context "on GET /:collections/:id/versions/_resolved" do
+
+        setup do
+          @etags = []
+          4.times do |i|
+            json = JSON.generate(:this => i)
+            options = {:input => json}.merge(VALID_TEST_AUTH)
+            options.filter_merge!('HTTP_IF_MATCH' => @etags.try(:last))
+            result = @request.put('/items/abc', options)
+            @etags << JSON.parse(result.body)['etag']
+          end
+          @response = @request.get(
+            '/items/abc/versions/_resolved', {'HTTP_HOST' => 'example.org'}.merge(VALID_TEST_AUTH))
+          @parsed_response = JSON.parse(@response.body)
+        end
+
+        should "be successful" do
+          assert_equal 200, @response.status
+        end
+
+        should "be successful even if the current resource has been deleted" do
+          @request.delete(
+            '/items/abc', {'HTTP_IF_MATCH' => @etags.last}.merge(VALID_TEST_AUTH))
+          response = @request.get('/items/abc/versions/_resolved', VALID_TEST_AUTH)
+          assert_equal 200, @response.status
+          parsed_response = JSON.parse(response.body)
+          assert_equal 4, parsed_response['documents'].size
+        end
+
+        should "return all versions of a document" do
+          documents = @parsed_response['documents']
+          assert documents
+          assert_equal 4, documents.size
+        end
+
+        should "return a 404 if the resource does not exist" do
+          response = @request.get('/items/nothing/versions/_resolved', VALID_TEST_AUTH)
+          assert_equal 404, response.status
+        end
+
+        should "return a 404 for non-owner-originated requests" do
+          response = @request.get('/items/abc/versions/_resolved', CLOUDKIT_AUTH_KEY => 'someoneelse')
+          assert_equal 404, response.status
+        end
+
+        should "sort descending on last_modified date" do
+          assert_equal(
+            ['/items/abc'].concat(@etags[0..-2].reverse.map{|e| "/items/abc/versions/#{e}"}),
+            @parsed_response['documents'].map{|d| d['uri']})
+        end
+
+        should "return the total number of documents" do
+          assert @parsed_response['total']
+          assert_equal 4, @parsed_response['total']
+        end
+
+        should "return the offset" do
+          assert @parsed_response['offset']
+          assert_equal 0, @parsed_response['offset']
+        end
+
+        should "return a Content-Type header" do
+          assert_equal 'application/json', @response['Content-Type']
+        end
+
+        should "return an ETag" do
+          assert @response['ETag']
+        end
+
+        should "return a Last-Modified date" do
+          assert @response['Last-Modified']
+        end
+
+        should "accept a limit parameter" do
+          response = @request.get(
+            '/items/abc/versions/_resolved?limit=2', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal ['/items/abc', "/items/abc/versions/#{@etags[-2]}"],
+            parsed_response['documents'].map{|d| d['uri']}
+          assert_equal 4, parsed_response['total']
+        end
+
+        should "accept an offset parameter" do
+          response = @request.get(
+            '/items/abc/versions/_resolved?offset=1', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal @etags.reverse[1..-1].map{|e| "/items/abc/versions/#{e}"},
+            parsed_response['documents'].map{|d| d['uri']}
+          assert_equal 1, parsed_response['offset']
+          assert_equal 4, parsed_response['total']
+        end
+
+        should "accept combined limit and offset parameters" do
+          response = @request.get(
+            '/items/abc/versions/_resolved?limit=1&offset=1', VALID_TEST_AUTH)
+          parsed_response = JSON.parse(response.body)
+          assert_equal ["/items/abc/versions/#{@etags[-2]}"],
+            parsed_response['documents'].map{|d| d['uri']}
+          assert_equal 1, parsed_response['offset']
+          assert_equal 4, parsed_response['total']
+        end
+
+        should "return an index link header" do
+          assert @response['Link']
+          assert @response['Link'].match("<http://example.org/items/abc/versions>; rel=\"index\"")
+        end
       end
 
       context "on GET /:collection/:id/versions/:etag" do
@@ -311,13 +527,13 @@ class ServiceTest < Test::Unit::TestCase
           @etags = []
           2.times do |i|
             json = JSON.generate(:this => i)
-            options = {:json => json, :remote_user => remote_user}
-            options.filter_merge!(:etag => @etags.try(:last))
-            result = @store.put('/items/abc', options)
-            @etags << result.parsed_content['etag']
+            options = {:input => json}.merge(VALID_TEST_AUTH)
+            options.filter_merge!('HTTP_IF_MATCH' => @etags.try(:last))
+            result = @request.put('/items/abc', options)
+            @etags << JSON.parse(result.body)['etag']
           end
           @response = @request.get(
-            "/items/abc/versions/#{@etags.first}", auth_key => remote_user)
+            "/items/abc/versions/#{@etags.first}", VALID_TEST_AUTH)
           @parsed_response = JSON.parse(@response.body)
         end
 
@@ -331,7 +547,7 @@ class ServiceTest < Test::Unit::TestCase
 
         should "return a 404 if a document is not found" do
           response = @request.get(
-            "/items/nothing/versions/#{@etags.first}", auth_key => remote_user)
+            "/items/nothing/versions/#{@etags.first}", VALID_TEST_AUTH)
           assert_equal 404, response.status
         end
 
@@ -349,7 +565,7 @@ class ServiceTest < Test::Unit::TestCase
 
         should "not return documents for unauthorized users" do
           response = @request.get(
-            "/items/abc/versions/#{@etags.first}", auth_key => 'someoneelse')
+            "/items/abc/versions/#{@etags.first}", CLOUDKIT_AUTH_KEY => 'someoneelse')
           assert_equal 404, response.status
         end
       end
@@ -359,12 +575,12 @@ class ServiceTest < Test::Unit::TestCase
         setup do
           json = JSON.generate(:this => 'that')
           @response = @request.post(
-            '/items', :input => json, auth_key => remote_user)
+            '/items', {:input => json}.merge(VALID_TEST_AUTH))
           @body = JSON.parse(@response.body)
         end
 
         should "store the document" do
-          result = @store.get(@body['uri'])
+          result = @request.get(@body['uri'], VALID_TEST_AUTH)
           assert_equal 200, result.status
         end
 
@@ -390,7 +606,7 @@ class ServiceTest < Test::Unit::TestCase
         end
 
         should "return a 422 if parsing fails" do
-          response = @request.post('/items', :input => 'fail', auth_key => remote_user)
+          response = @request.post('/items', {:input => 'fail'}.merge(VALID_TEST_AUTH))
           assert_equal 422, response.status
         end
 
@@ -417,31 +633,32 @@ class ServiceTest < Test::Unit::TestCase
 
         setup do
           json = JSON.generate(:this => 'that')
-          @original = @store.put('/items/abc', :json => json, :remote_user => remote_user)
-          etag = @original.parsed_content['etag']
-          json = JSON.generate(:this => 'other', :etag => etag)
+          @original = @request.put(
+            '/items/abc', {:input => json}.merge(VALID_TEST_AUTH))
+          etag = JSON.parse(@original.body)['etag']
+          json = JSON.generate(:this => 'other')
           @response = @request.put(
             '/items/abc',
-            :input          => json,
-            'HTTP_IF_MATCH' => etag,
-            auth_key        => remote_user)
+            :input            => json,
+            'HTTP_IF_MATCH'   => etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           @json = JSON.parse(@response.body)
         end
 
         should "create a document if it does not already exist" do
           json = JSON.generate(:this => 'thing')
           response = @request.put(
-            '/items/xyz', :input => json, auth_key => remote_user)
+            '/items/xyz', {:input => json}.merge(VALID_TEST_AUTH))
           assert_equal 201, response.status
-          result = @store.get('/items/xyz')
+          result = @request.get('/items/xyz', VALID_TEST_AUTH)
           assert_equal 200, result.status
-          assert_equal 'thing', result.parsed_content['this']
+          assert_equal 'thing', JSON.parse(result.body)['this']
         end
 
         should "update the document if it already exists" do
           assert_equal 200, @response.status
-          result = @store.get('/items/abc').parsed_content
-          assert_equal 'other', result['this']
+          result = @request.get('/items/abc', VALID_TEST_AUTH)
+          assert_equal 'other', JSON.parse(result.body)['this']
         end
 
         should "return the metadata" do
@@ -465,9 +682,9 @@ class ServiceTest < Test::Unit::TestCase
           json = JSON.generate(:this => 'other')
           response = @request.put(
             '/items/abc',
-            :input          => json,
-            'HTTP_IF_MATCH' => @json['etag'],
-            auth_key        => 'someone_else')
+            :input            => json,
+            'HTTP_IF_MATCH'   => @json['etag'],
+            CLOUDKIT_AUTH_KEY => 'someone_else')
           assert_equal 404, response.status
         end
 
@@ -476,15 +693,15 @@ class ServiceTest < Test::Unit::TestCase
           client_b_input = JSON.generate(:other => 'thing')
           response = @request.put(
             '/items/abc',
-            :input          => client_a_input,
-            'HTTP_IF_MATCH' => @json['etag'],
-            auth_key        => remote_user)
+            :input            => client_a_input,
+            'HTTP_IF_MATCH'   => @json['etag'],
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 200, response.status
           response = @request.put(
             '/items/abc',
-            :input          => client_b_input,
-            'HTTP_IF_MATCH' => @json['etag'],
-            auth_key        => remote_user)
+            :input            => client_b_input,
+            'HTTP_IF_MATCH'   => @json['etag'],
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 412, response.status
         end
 
@@ -492,14 +709,13 @@ class ServiceTest < Test::Unit::TestCase
           json = JSON.generate(:this => 'updated')
           response = @request.put(
             '/items/abc',
-            :input   => json,
-            auth_key => remote_user)
+            {:input   => json}.merge(VALID_TEST_AUTH))
           assert_equal 400, response.status
         end
 
         should "return a 422 if parsing fails" do
           response = @request.put(
-            '/items/zzz', :input => 'fail', auth_key => remote_user)
+            '/items/zzz', {:input => 'fail'}.merge(VALID_TEST_AUTH))
           assert_equal 422, response.status
         end
 
@@ -509,15 +725,15 @@ class ServiceTest < Test::Unit::TestCase
             '/items/abc',
             :input          => json,
             'HTTP_IF_MATCH' => @json['etag'],
-            auth_key        => remote_user)
+            CLOUDKIT_AUTH_KEY        => TEST_REMOTE_USER)
           assert_equal 200, response.status
           etag = JSON.parse(response.body)['etag']
           json = JSON.generate(:this => 'updated again')
           new_response = @request.put(
             '/items/abc',
-            :input          => json,
-            'HTTP_IF_MATCH' => etag,
-            auth_key        => remote_user)
+            :input            => json,
+            'HTTP_IF_MATCH'   => etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 200, new_response.status
           new_etag = JSON.parse(new_response.body)['etag']
           assert_not_equal etag, new_etag
@@ -550,25 +766,26 @@ class ServiceTest < Test::Unit::TestCase
 
         setup do
           json = JSON.generate(:this => 'that')
-          @result = @store.put('/items/abc', :json => json, :remote_user => remote_user)
-          @etag = @result.parsed_content['etag']
+          @result = @request.put(
+            '/items/abc', {:input => json}.merge(VALID_TEST_AUTH))
+          @etag = JSON.parse(@result.body)['etag']
         end
 
         should "delete the document" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 200, response.status
-          result = @store.get('/items/abc')
+          result = @request.get('/items/abc', VALID_TEST_AUTH)
           assert_equal 410, result.status
         end
 
         should "return the metadata" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           json = JSON.parse(response.body)
           assert_equal 4, json.keys.size
           assert_same_elements ['ok', 'uri', 'etag', 'last_modified'], json.keys
@@ -577,79 +794,80 @@ class ServiceTest < Test::Unit::TestCase
         should "set the Content-Type header" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 'application/json', response['Content-Type']
         end
 
         should "not set an ETag header" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_nil response['ETag']
         end
 
         should "not set a Last-Modified header" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_nil response['Last-Modified']
         end
 
         should "return a 404 for items that have never existed" do
           response = @request.delete(
             '/items/zzz',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 404, response.status
         end
 
         should "require an ETag" do
           response = @request.delete(
             '/items/abc',
-            auth_key => remote_user)
+            VALID_TEST_AUTH)
           assert_equal 400, response.status
         end
 
         should "verify the user in the doc" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => 'someoneelse')
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => 'someoneelse')
           assert_equal 404, response.status
         end
 
         should "detect and return conflicts" do
           json = JSON.generate(:this => 'that')
-          result = @store.put('/items/123', :json => json, :remote_user => remote_user)
-          etag = result.parsed_content['etag']
+          result = @request.put(
+            '/items/123', {:input => json}.merge(VALID_TEST_AUTH))
+          etag = JSON.parse(result.body)['etag']
           client_a_input = JSON.generate(:this => 'updated')
           client_b_input = JSON.generate(:other => 'thing')
           response = @request.put(
             '/items/123',
-            :input          => client_a_input,
-            'HTTP_IF_MATCH' => etag,
-            auth_key        => remote_user)
+            :input            => client_a_input,
+            'HTTP_IF_MATCH'   => etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 200, response.status
           response = @request.delete(
             '/items/123',
-            :input          => client_b_input,
-            'HTTP_IF_MATCH' => etag,
-            auth_key        => remote_user)
+            :input            => client_b_input,
+            'HTTP_IF_MATCH'   => etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 412, response.status
         end
 
         should "retain version history" do
           response = @request.delete(
             '/items/abc',
-            'HTTP_IF_MATCH' => @etag,
-            auth_key        => remote_user)
+            'HTTP_IF_MATCH'   => @etag,
+            CLOUDKIT_AUTH_KEY => TEST_REMOTE_USER)
           assert_equal 200, response.status
           response = @request.get(
             '/items/abc/versions',
-            auth_key => remote_user)
+            VALID_TEST_AUTH)
           json = JSON.parse(response.body)
           assert_equal 1, json['total']
         end
@@ -674,7 +892,7 @@ class ServiceTest < Test::Unit::TestCase
       context "on OPTIONS /:collection" do
 
         setup do
-          @response = @request.request('OPTIONS', '/items', auth_key => remote_user)
+          @response = @request.request('OPTIONS', '/items', VALID_TEST_AUTH)
         end
 
         should "return a 200 status" do
@@ -688,10 +906,13 @@ class ServiceTest < Test::Unit::TestCase
         end
       end
 
+      context "on OPTIONS /:collection/_resolved" do
+      end
+
       context "on OPTIONS /:collection/:id" do
 
         setup do
-          @response = @request.request('OPTIONS', '/items/xyz', auth_key => remote_user)
+          @response = @request.request('OPTIONS', '/items/xyz', VALID_TEST_AUTH)
         end
 
         should "return a 200 status" do
@@ -708,6 +929,9 @@ class ServiceTest < Test::Unit::TestCase
       context "on OPTIONS /:collection/:id/versions" do
       end
 
+      context "on OPTIONS /:collection/:id/versions/_resolved" do
+      end
+
       context "on OPTIONS /:collection/:id/versions/:etag" do
       end
 
@@ -715,10 +939,10 @@ class ServiceTest < Test::Unit::TestCase
 
         should "return an empty body" do
           json = JSON.generate(:this => 'that')
-          @store.put('/items/abc', :json => json, :remote_user => remote_user)
-          response = @request.request('HEAD', '/items/abc', auth_key => remote_user)
+          @request.put('/items/abc', {:input => json}.merge(VALID_TEST_AUTH))
+          response = @request.request('HEAD', '/items/abc', VALID_TEST_AUTH)
           assert_equal '', response.body
-          response = @request.request('HEAD', '/items', auth_key => remote_user)
+          response = @request.request('HEAD', '/items', VALID_TEST_AUTH)
           assert_equal '', response.body
         end