cloudkit 0.10.1 → 0.11.0

data/spec/oauth_store_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "An OAuthStore" do
+
+  it "should know its version" do
+    store = CloudKit::UserStore.new
+    store.version.should == 1
+  end
+
+end

data/spec/openid_filter_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "An OpenIDFilter" do
+
+  before(:each) do
+    openid_app = Rack::Builder.new {
+      use Rack::Lint
+      use Rack::Session::Pool
+      use CloudKit::OpenIDFilter, :allow => ['/foo']
+      run echo_env(CLOUDKIT_AUTH_KEY)
+    }
+    @request = Rack::MockRequest.new(openid_app)
+  end
+
+  it "should allow root url pass through" do
+    response = @request.get('/')
+    response.status.should == 200
+  end
+
+  it "should allow pass through of URIs defined in :allow" do
+    response = @request.get('/foo')
+    response.status.should == 200
+  end
+
+  it "should redirect to the login page if authorization is required" do
+    response = @request.get('/protected')
+    response.status.should == 302
+    response['Location'].should == '/login'
+  end
+
+  it "should notify downstream nodes of its presence" do
+    app = Rack::Builder.new do
+      use Rack::Session::Pool
+      use CloudKit::OpenIDFilter
+      run echo_env(CLOUDKIT_VIA)
+    end
+    response = Rack::MockRequest.new(app).get('/')
+    response.body.should == CLOUDKIT_OPENID_FILTER_KEY
+  end
+
+  describe "with upstream authorization middleware" do
+
+    it "should allow pass through if the auth env variable is populated" do
+      response = @request.get('/protected', VALID_TEST_AUTH)
+      response.status.should == 200
+      response.body.should == TEST_REMOTE_USER
+    end
+
+    it "should return the auth challenge header" do
+      response = @request.get('/protected',
+        CLOUDKIT_VIA => CLOUDKIT_OAUTH_FILTER_KEY,
+        CLOUDKIT_AUTH_CHALLENGE => {'WWW-Authenticate' => 'etc.'})
+      response['WWW-Authenticate'].should_not be_nil
+    end
+
+    it "should return a 401 status if authorization is required" do
+      response = @request.get('/protected',
+        CLOUDKIT_VIA => CLOUDKIT_OAUTH_FILTER_KEY,
+        CLOUDKIT_AUTH_CHALLENGE => {'WWW-Authenticate' => 'etc.'})
+      response.status.should == 401
+    end
+
+  end
+end

data/spec/openid_store_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "An OpenIDStore" do
+
+  before(:each) do
+    CloudKit.setup_storage_adapter unless CloudKit.storage_adapter
+    @store = CloudKit::OpenIDStore.new
+    @server = 'http://openid.claimid.com/server'
+    @handle = "{HMAC-SHA1}{736kwv3j}{wbhwEK==}"
+    @secret = "\350\068\753\436\567\8327\232\241\025\254\3117&\016\031\355#sV"
+    @issued = Time.now
+    @lifetime = 120960
+    @type = "HMAC-SHA1"
+    @association = OpenID::Association.new(@handle, @secret, @issued, @lifetime, @type)
+    @store.store_association(@server, @association)
+    @result = CloudKit::Resource.all.first.parsed_json
+  end
+  
+  after(:each) do
+    CloudKit.storage_adapter.clear
+  end
+
+  it "should know its version" do
+    @store.version.should == 1
+  end
+
+  describe "when storing an association" do
+
+    it "should base64 encode the handle" do
+      @result['handle'].should == Base64.encode64(@handle)
+    end
+
+    it "should base64 encode the secret" do
+      @result['secret'].should == Base64.encode64(@secret)
+    end
+
+    it "should convert the issue time to an integer" do
+      @result['issued'].should == @issued.to_i
+    end
+
+    it "should store the lifetime as given" do
+      @result['lifetime'].should == @lifetime
+    end
+
+    it "should store the association type as given" do
+      @result['assoc_type'].should == @type
+    end
+
+    it "should remove previous associations with the given server_url and association handle" do
+      association = OpenID::Association.new(@handle, @secret, @issued, @lifetime, @type)
+      @store.store_association(@server, association)
+      associations = CloudKit::Resource.current(
+        :collection_reference => "/cloudkit_openid_associations")
+      associations.size.should == 1
+      result = associations.first.parsed_json
+      result['secret'].should == Base64.encode64(@secret)
+    end
+  end
+
+  describe "when removing an association" do
+
+    it "should succeed" do
+      @store.remove_association(@server, @association.handle)
+      associations = CloudKit::Resource.current(
+        :collection_reference => "/cloudkit_openid_associations")
+      associations.size.should == 0
+    end
+  end
+
+  describe "when finding an association" do
+
+    it "should return the correct object" do
+      association = @store.get_association(@server, @association.handle)
+      association.should == @association
+    end
+  end
+
+  describe "when using a nonce" do
+
+    before(:each) do
+      @time = Time.now.to_i
+      @salt = 'salt'
+      @store.use_nonce(@server, @time, @salt)
+    end
+
+    it "should store the nonce" do
+      nonce = CloudKit::Resource.first(
+        :collection_reference => "/cloudkit_openid_nonces",
+        :deleted              => false)
+      nonce.should_not be_nil
+    end
+
+    it "should reject the nonce if it has already been used" do
+      @store.use_nonce(@server, @time, @salt).should_not be_nil
+      nonces = CloudKit::Resource.all(
+        :collection_reference => "/cloudkit_openid_nonces",
+        :deleted              => false)
+      nonces.size.should == 1
+    end
+  end
+end

data/spec/rack_builder_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Rack::Builder" do
+
+  it "should expose services" do
+    app = Rack::Builder.new do
+      expose :items, :things
+      run lambda {|app| [200, {}, ['hello']]}
+    end
+    response = Rack::MockRequest.new(app).get('/items')
+    response.status.should == 200
+    documents = JSON.parse(response.body)['uris']
+    documents.should == []
+  end
+
+  it "should expose services with auth using 'contain'" do
+    app = Rack::Builder.new do
+      contain :items, :things
+      run lambda {|app| [200, {}, ['hello']]}
+    end
+    response = Rack::MockRequest.new(app).get('/items')
+    response.status.should == 401
+    response = Rack::MockRequest.new(app).get('/things')
+    response.status.should == 401
+    response = Rack::MockRequest.new(app).get('/')
+    response.status.should == 200
+    response.body.should == 'hello'
+  end
+
+  it "should insert a default app if one does not exist" do
+    app = Rack::Builder.new { contain :items }
+    response = Rack::MockRequest.new(app).get('/items')
+    response.status.should == 401
+    response = Rack::MockRequest.new(app).get('/')
+    response.status.should == 200
+    response.body.match('CloudKit').should_not be_nil
+  end
+
+end

data/spec/request_spec.rb

@@ -0,0 +1,185 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "A Request" do
+
+  it "should match requests with routes" do
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com')).match?('GET', '/').should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/')).match?('GET', '/').should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/')).match?('POST', '/').should_not be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello')).match?('GET', '/hello').should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello')).match?('GET', '/hello').should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello', :method => 'POST')).match?(
+        'POST', '/hello').should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q=a', :method => 'POST')).match?(
+        'POST', '/hello', [{'q' => 'a'}]).should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q=a', :method => 'POST')).match?(
+        'POST', '/hello', ['q']).should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q=a', :method => 'POST')).match?(
+        'POST', '/hello', [{'q' => 'b'}]).should_not be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q', :method => 'POST')).match?(
+        'POST', '/hello', [{'q' => nil}]).should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q=a', :method => 'POST')).match?(
+        'POST', '/hello', [{'q' => nil}]).should_not be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q=a', :method => 'POST')).match?(
+        'POST', '/hello', [{'q' => ''}]).should_not be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q&x=y', :method => 'PUT')).match?(
+        'PUT', '/hello', ['q', {'x' => 'y'}]).should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q&x=y&z', :method => 'PUT')).match?(
+        'PUT', '/hello', ['q', {'x' => 'y'}]).should be_true
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello?q&x=y', :method => 'PUT')).match?(
+        'PUT', '/hello', [{'q' => 'a'},{'x' => 'y'}]).should_not be_true
+  end
+
+  it "should treat a trailing :id as a wildcard for path matching" do
+    CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://example.com/hello/123')).match?('GET', '/hello/:id').should be_true
+  end
+
+  it "should inject stack-internal via-style env vars" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/test'))
+    request.via.should == []
+    request.inject_via('a.b')
+    request.via.include?('a.b').should be_true
+    request.inject_via('c.d')
+    request.via.include?('a.b').should be_true
+    request.via.include?('c.d').should be_true
+  end
+
+  it "should announce the use of auth middleware" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.announce_auth(CLOUDKIT_OAUTH_FILTER_KEY)
+    request.via.include?(CLOUDKIT_OAUTH_FILTER_KEY).should be_true
+  end
+
+  it "should know if auth provided by upstream middleware" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.announce_auth(CLOUDKIT_OAUTH_FILTER_KEY)
+    request.using_auth?.should be_true
+  end
+
+  it "should know the current user" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.current_user.should be_nil
+    request = CloudKit::Request.new(
+      Rack::MockRequest.env_for('/', CLOUDKIT_AUTH_KEY => 'cecil'))
+    request.current_user.should_not be_nil
+    request.current_user.should == 'cecil'
+  end
+
+  it "should set the current user" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.current_user = 'cecil'
+    request.current_user.should_not be_nil
+    request.current_user.should == 'cecil'
+  end
+
+  it "should know the login url" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.login_url.should == '/login'
+    request = CloudKit::Request.new(
+      Rack::MockRequest.env_for('/', CLOUDKIT_LOGIN_URL => '/sessions'))
+    request.login_url.should == '/sessions'
+  end
+
+  it "should set the login url" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.login_url = '/welcome'
+    request.login_url.should == '/welcome'
+  end
+
+  it "should know the logout url" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.logout_url.should == '/logout'
+    request = CloudKit::Request.new(
+      Rack::MockRequest.env_for('/', CLOUDKIT_LOGOUT_URL => '/sessions'))
+    request.logout_url.should == '/sessions'
+  end
+
+  it "should set the logout url" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.logout_url = '/goodbye'
+    request.logout_url.should == '/goodbye'
+  end
+
+  it "should get the session" do
+    request = CloudKit::Request.new(
+      Rack::MockRequest.env_for('/', 'rack.session' => 'this'))
+    request.session.should_not be_nil
+    request.session.should == 'this'
+  end
+
+  it "should know the flash" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      '/', 'rack.session' => {}))
+    request.flash.is_a?(CloudKit::FlashSession).should be_true
+  end
+
+  it "should parse if-match headers" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      '/items/123/versions'))
+    request.if_match.should be_nil
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      '/items/123/versions', 'HTTP_IF_MATCH' => '"a"'))
+    request.if_match.should == 'a'
+  end
+
+  it "should treat a list of etags in an if-match header as a single etag" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      '/items/123/versions', 'HTTP_IF_MATCH' => '"a", "b"'))
+    # See CloudKit::Request#if_match for more info on this expectation
+    request.if_match.should == 'a", "b'
+  end
+
+  it "should ignore if-match when set to *" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      '/items/123/versions', 'HTTP_IF_MATCH' => '*'))
+    request.if_match.should be_nil
+  end
+
+  it "should understand header auth" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      'http://photos.example.net/photos?file=vacation.jpg&size=original',
+      'Authorization' =>
+      'OAuth realm="",' + 
+      'oauth_version="1.0",' +
+      'oauth_consumer_key="dpf43f3p2l4k3l03",' +
+      'oauth_token="nnch734d00sl2jdk",' +
+      'oauth_timestamp="1191242096",' +
+      'oauth_nonce="kllo9940pd9333jh",' +
+      'oauth_signature="tR3%2BTy81lMeYAr%2FFid0kMTYa%2FWM%3D",' +
+      'oauth_signature_method="HMAC-SHA1"'))
+    request['oauth_consumer_key'].should == 'dpf43f3p2l4k3l03'
+    request['oauth_token'].should == 'nnch734d00sl2jdk'
+    request['oauth_timestamp'].should == '1191242096'
+    request['oauth_nonce'].should == 'kllo9940pd9333jh'
+    request['oauth_signature'].should == 'tR3+Ty81lMeYAr/Fid0kMTYa/WM='
+    request['oauth_signature_method'].should == 'HMAC-SHA1'
+  end
+
+  it "should know the last path element" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/'))
+    request.last_path_element.should be_nil
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/abc'))
+    request.last_path_element.should == 'abc'
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/abc/'))
+    request.last_path_element.should == 'abc'
+    request = CloudKit::Request.new(Rack::MockRequest.env_for('/abc/def'))
+    request.last_path_element.should == 'def'
+  end
+
+end

data/spec/resource_spec.rb

@@ -0,0 +1,291 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "A Resource" do
+
+  before(:all) do
+    CloudKit.setup_storage_adapter unless CloudKit.storage_adapter
+  end
+
+  after(:each) do
+    CloudKit.storage_adapter.clear
+  end
+
+  describe "on initialization" do
+
+    before(:each) do
+      @resource = CloudKit::Resource.new(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+    end
+
+    it "should know its uri" do
+      @resource.uri.string.should == CloudKit::URI.new('/items/123').string
+    end
+
+    it "should know its json" do
+      @resource.json.should == "{\"foo\":\"bar\"}"
+    end
+
+    it "should know its remote user" do
+      @resource.remote_user.should == 'http://eric.dolphy.info'
+    end
+
+    it "should default its deleted status to false" do
+      @resource.should_not be_deleted
+    end
+
+    it "should default its archived status to false" do
+      @resource.should_not be_archived
+    end
+
+    it "should default its etag to nil" do
+      @resource.etag.should be_nil
+    end
+
+    it "should default its last-modified date to nil" do
+      @resource.last_modified.should be_nil
+    end
+
+    it "should know if it is current" do
+      @resource.should be_current
+    end
+
+  end
+
+  describe "on save" do
+
+    before(:each) do
+      @resource = CloudKit::Resource.new(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+      @resource.save
+    end
+
+    it "should set its etag" do
+      @resource.etag.should_not be_nil
+    end
+
+    it "should set its last modified date" do
+      @resource.last_modified.should_not be_nil
+    end
+
+    it "should adjust its URI when adding to a resource collection" do
+      resource = CloudKit::Resource.new(
+        CloudKit::URI.new('/items'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+      resource.save
+      resource.uri.string.should_not == '/items'
+    end
+
+    it "should flatten its json structure for querying" do
+      hash = CloudKit.storage_adapter.query.first
+      hash.keys.include?('foo').should be_true
+    end
+
+    it "should know it is current" do
+      @resource.should be_current
+    end
+
+  end
+
+  describe "on create" do
+
+    before(:each) do
+      resource = CloudKit::Resource.create(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+      @result = CloudKit.storage_adapter.query { |q|
+        q.add_condition 'uri', :eql, '/items/123'
+      }
+    end
+
+    it "should save the resource" do
+      @result.size.should == 1
+      @result.first['json'].should == "{\"foo\":\"bar\"}"
+    end
+
+  end
+
+  describe "on update" do
+
+    before(:each) do
+      @resource = CloudKit::Resource.create(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+      @original_resource = @resource.dup
+      now = Time.now
+      Time.stub!(:now).and_return(now+1)
+      @resource.update(JSON.generate({:foo => 'baz'}))
+    end
+
+    it "should version the resource" do
+      @resource.versions.size.should == 2
+      @resource.versions[-1].should be_archived
+    end
+
+    it "should set a new etag" do
+      @resource.etag.should_not == @original_resource.etag
+    end
+
+    it "should set a new last modified date" do
+      @resource.last_modified.should_not == @original_resource.last_modified
+    end
+
+    it "should fail on archived resource versions" do
+      lambda {
+        @resource.versions[-1].update({:foo => 'box'})
+      }.should raise_error(CloudKit::HistoricalIntegrityViolation)
+    end
+
+    it "should fail on deleted resource versions" do
+      lambda {
+        @resource.delete
+        @resource.update({:foo => 'box'})
+      }.should raise_error(CloudKit::HistoricalIntegrityViolation)
+    end
+
+  end
+
+  describe "on delete" do
+
+    before(:each) do
+      @resource = CloudKit::Resource.create(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+      now = Time.now
+      Time.stub!(:now).and_return(now+1)
+      @resource.delete
+    end
+
+    it "should version the resource" do
+      @resource.versions.size.should == 2
+      @resource.versions[-1].should be_archived
+    end
+
+    it "should set the etag on the main resource to nil" do
+      @resource.etag.should be_nil
+    end
+
+    it "should know it has been deleted" do
+      @resource.deleted?.should be_true
+    end
+
+    it "should fail on archived resource versions" do
+      lambda {
+        @resource.versions[-1].update({:foo => 'box'})
+      }.should raise_error(CloudKit::HistoricalIntegrityViolation)
+    end
+
+  end
+
+  describe "with versions" do
+
+    before(:each) do
+      @resource = CloudKit::Resource.create(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate({:foo => 'bar'}),
+        'http://eric.dolphy.info')
+      @resource_list = [@resource.dup]
+
+      2.times { |i|
+        now = Time.now
+        Time.stub!(:now).and_return(now+1)
+        @resource.update(JSON.generate({:foo => i}))
+        @resource_list << @resource.dup
+      }
+      @resource_list.reverse!
+    end
+
+    it "should keep an ordered list of versions" do
+      @resource.versions.map { |version| version.last_modified }.
+        should == @resource_list.map { |version| version.last_modified }
+    end
+
+    it "should include the current version in the version list" do
+      current_ts = @resource.last_modified
+      @resource_list.map { |version| version.last_modified }.should include(current_ts)
+    end
+
+    it "should know its previous version" do
+      @resource.previous_version.last_modified.should == @resource_list[1].last_modified
+    end
+
+    it "should know its previous versions" do
+      expected_times = @resource_list[1..-1].map { |version| version.last_modified }
+      @resource.previous_versions.map { |version| version.last_modified }.should == expected_times
+    end
+
+  end
+
+  describe "when finding" do
+
+    before(:each) do
+      ['bar', 'baz'].each do |value|
+        CloudKit::Resource.create(
+          CloudKit::URI.new('/items'),
+          JSON.generate({:foo => value}),
+          "http://eric.dolphy.info/#{value}_user")
+      end
+      CloudKit::Resource.create(
+        CloudKit::URI.new('/items'),
+        JSON.generate({:foo => 'box'}),
+        "http://eric.dolphy.info/bar_user")
+    end
+
+    describe "using #all" do
+
+      it "should find matching resources" do
+        result = CloudKit::Resource.all(
+          :remote_user => 'http://eric.dolphy.info/bar_user')
+        result.size.should == 2
+        result.map { |item| item.remote_user.should == 'http://eric.dolphy.info/bar_user' }
+      end
+
+      it "should return all elements if no restrictions are given" do 
+        CloudKit::Resource.all.size.should == 3
+      end
+
+      it "should return an empty array if no resources are found" do
+        CloudKit::Resource.all(:uri => 'fail').should be_empty
+      end
+
+      it "should find with query parameters referencing JSON elements" do
+        resources = CloudKit::Resource.all(
+          :collection_reference => '/items',
+          :foo => 'bar')
+        resources.size.should == 1
+        resources.first.json.should == "{\"foo\":\"bar\"}"
+      end
+
+    end
+
+    describe "on #first" do
+
+      it "should find the first matching resource" do
+        result = CloudKit::Resource.first(:remote_user => 'http://eric.dolphy.info/bar_user')
+        result.should_not === Array
+        result.remote_user.should == 'http://eric.dolphy.info/bar_user'
+        result.parsed_json['foo'].should == 'box' # all listings are reverse ordered
+      end
+
+    end
+
+    describe "on #current" do
+
+      it "should find only current matching resources" do
+        resource = CloudKit::Resource.first(:remote_user => 'http://eric.dolphy.info/bar_user')
+        resource.update(JSON.generate({:foo => 'x'}))
+        CloudKit::Resource.current(:collection_reference => '/items').size.should == 3
+      end
+
+    end
+
+  end
+
+end