cloudkit-jruby 0.11.2

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,191 @@
+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
+
+  it "should know its domain root" do
+    request = CloudKit::Request.new(Rack::MockRequest.env_for(
+      '/', 'HTTP_HOST' => 'example.com'))
+    request.domain_root.should == "http://example.com"
+  end
+
+end

data/spec/resource_spec.rb

@@ -0,0 +1,310 @@
+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
+
+    def store_json(hash)
+      CloudKit::Resource.create(
+        CloudKit::URI.new('/items/123'),
+        JSON.generate(hash),
+        'http://eric.dolphy.info')
+      CloudKit.storage_adapter.query { |q|
+        q.add_condition 'uri', :eql, '/items/123'
+      }
+    end
+
+    it "should save the resource" do
+      result = store_json({:foo => 'bar'})
+      result.size.should == 1
+      result.first['json'].should == "{\"foo\":\"bar\"}"
+    end
+
+    it "should accept nested array values" do
+      result = store_json({:foo => [1,2]})
+      result.size.should == 1
+      result.first['json'].should == '{"foo":[1,2]}'
+    end
+
+    it "should accept nested hash values" do
+      result = store_json({:foo => {:bar => 'baz'}})
+      result.size.should == 1
+      result.first['json'].should == '{"foo":{"bar":"baz"}}'
+    end
+
+    it "should accept recursively nested array/hash values" do
+      result = store_json({:foo => [1,{:bar => [2,3]}]})
+      result.size.should == 1
+      result.first['json'].should == '{"foo":[1,{"bar":[2,3]}]}'
+    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