ripple 1.0.0.beta → 1.0.0.beta2

data/spec/ripple/conversion_spec.rb

@@ -2,21 +2,13 @@ require 'spec_helper'
 
 describe Ripple::Conversion do
   # require 'support/models/box'
+  subject { Box.new { |a| a.key = 'some-key' } }
 
   before :each do
-    @box = Box.new { |a| a.key = 'some-key' }
-    @box.stub!(:new?).and_return(false)
+    subject.stub!(:new?).and_return(false)
   end
 
-  it "should return the key as an array for to_key" do
-    @box.to_key.should == ['some-key']
-  end
-
-  it "should be able to be converted to a param" do
-    @box.to_param.should == 'some-key'
-  end
-
-  it "should be able to be converted to a model" do
-    @box.to_model.should == @box
-  end
+  its(:to_key)  { should == ['some-key'] }
+  its(:to_param){ should == 'some-key'   }
+  its(:to_model){ should == subject      }
 end

data/spec/ripple/core_ext_spec.rb

@@ -3,64 +3,103 @@ require 'spec_helper'
 describe Time do
   before { @date_format = Ripple.date_format }
   after  { Ripple.date_format = @date_format }
-
+  subject { Time.utc(2010,3,16,12) }
   it "serializes to JSON in UTC, ISO 8601 format by default" do
-    Time.utc(2010,3,16,12).as_json.should == "2010-03-16T12:00:00Z"
+    subject.as_json.should == "2010-03-16T12:00:00Z"
   end
 
   it "serializes to JSON in UTC, RFC822 format when specified" do
     Ripple.date_format = :rfc822
-    Time.utc(2010,3,16,12).as_json.should == "Tue, 16 Mar 2010 12:00:00 -0000"
+    subject.as_json.should == "Tue, 16 Mar 2010 12:00:00 -0000"
+  end
+
+  context "converting to an index value" do
+    it "should convert to an integer epoch milliseconds for 'int' type" do
+      subject.to_ripple_index('int').should == 1268740800000
+    end
+
+    it "should convert to the date format for 'bin' type" do
+      subject.to_ripple_index('bin').should == "2010-03-16T12:00:00Z"
+    end
   end
 end
 
 describe Date do
   before { @date_format = Ripple.date_format }
   after  { Ripple.date_format = @date_format }
-
+  subject { Date.civil(2010,3,16) }
   it "serializes to JSON ISO 8601 format by default" do
-    Date.civil(2010,3,16).as_json.should == "2010-03-16"
+    subject.as_json.should == "2010-03-16"
   end
 
   it "serializes to JSON in UTC, RFC822 format when specified" do
     Ripple.date_format = :rfc822
-    Date.civil(2010,3,16).as_json.should == "16 Mar 2010"
+    subject.as_json.should == "16 Mar 2010"
+  end
+
+  context "converting to an index value" do
+    it "should convert to an integer epoch milliseconds for 'int' type" do
+      subject.to_ripple_index('int').should == 1268697600000
+    end
+
+    it "should convert to the date format for 'bin' type" do
+      subject.to_ripple_index('bin').should == "2010-03-16"
+    end
   end
 end
 
 describe DateTime do
   before { @date_format = Ripple.date_format }
   after  { Ripple.date_format = @date_format }
-
+  subject { DateTime.civil(2010,3,16,12) }
   before :each do
     Time.zone = "UTC"
   end
 
   it "serializes to JSON in UTC, ISO 8601 format by default" do
-    DateTime.civil(2010,3,16,12).as_json.should == "2010-03-16T12:00:00+00:00"
+    subject.as_json.should == "2010-03-16T12:00:00+00:00"
   end
 
   it "serializes to JSON in UTC, RFC822 format when specified" do
     Ripple.date_format = :rfc822
-    DateTime.civil(2010,3,16,12).as_json.should == "Tue, 16 Mar 2010 12:00:00 +0000"
+    subject.as_json.should == "Tue, 16 Mar 2010 12:00:00 +0000"
+  end
+
+  context "converting to an index value" do
+    it "should convert to an integer epoch milliseconds for 'int' type" do
+      subject.to_ripple_index('int').should == 1268740800000
+    end
+
+    it "should convert to the date format for 'bin' type" do
+      subject.to_ripple_index('bin').should == "2010-03-16T12:00:00+00:00"
+    end
   end
 end
 
 describe ActiveSupport::TimeWithZone do
   before { @date_format = Ripple.date_format }
   after  { Ripple.date_format = @date_format }
+  let(:time) { Time.utc(2010,3,16,12) }
+  let(:zone) { ActiveSupport::TimeZone['Alaska'] }
+  subject { ActiveSupport::TimeWithZone.new(time, zone) }
 
   it "serializes to JSON in UTC, ISO 8601 format by default" do
-    time = Time.utc(2010,3,16,12)
-    zone = ActiveSupport::TimeZone['Alaska']
-    ActiveSupport::TimeWithZone.new(time, zone).as_json.should == "2010-03-16T12:00:00Z"
+    subject.as_json.should == "2010-03-16T12:00:00Z"
   end
 
   it "serializes to JSON in UTC, RFC822 format when specified" do
     Ripple.date_format = :rfc822
-    time = Time.utc(2010,3,16,12)
-    zone = ActiveSupport::TimeZone['Alaska']
-    ActiveSupport::TimeWithZone.new(time, zone).as_json.should == "Tue, 16 Mar 2010 12:00:00 -0000"
+    subject.as_json.should == "Tue, 16 Mar 2010 12:00:00 -0000"
+  end
+
+  context "converting to an index value" do
+    it "should convert to an integer epoch milliseconds for 'int' type" do
+      subject.to_ripple_index('int').should == 1268740800000
+    end
+
+    it "should convert to the date format for 'bin' type" do
+      subject.to_ripple_index('bin').should == "2010-03-16T12:00:00Z"
+    end
   end
 end
 
@@ -79,6 +118,23 @@ describe String do
     'Tue, 16 Mar 2010 12:00:00 +0000'.to_datetime.should == DateTime.civil(2010,3,16,12)
     '2010-03-16T12:00:00+00:00'.to_datetime.should == DateTime.civil(2010,3,16,12)
   end
+
+  context "converting to an index value" do
+    subject { "1234" }
+
+    it "should not be treated as an Enumerable" do
+      subject.should_not_receive(:map)
+      subject.to_ripple_index('bin')
+    end
+
+    it "should convert to a binary index" do
+      subject.to_ripple_index('bin').should == subject
+    end
+
+    it "should convert to an integer index" do
+      subject.to_ripple_index('int').should == 1234
+    end
+  end
 end
 
 describe "Boolean" do
@@ -101,3 +157,25 @@ describe Set do
   end
 end
 
+describe Enumerable do
+  subject { [1,2,3] }
+  let(:int) { subject.to_ripple_index('int') }
+  let(:bin) { subject.to_ripple_index('bin') }
+
+  context "converting to an index value" do
+    it "should convert to a Set of strings for 'bin' type" do
+      bin.should be_kind_of(Set)
+      %w{1 2 3}.each do |i|
+        bin.should include(i)
+      end
+    end
+
+    it "should convert to a Set of integers for 'int' type" do
+      int.should be_kind_of(Set)
+      subject.each do |i|
+        int.should include(i)
+      end
+    end
+  end
+end
+

data/spec/ripple/finders_spec.rb

@@ -5,9 +5,7 @@ describe Ripple::Document::Finders do
   # require 'support/models/cardboard_box'
 
   before :each do
-    @backend = mock("Backend")
     @client = Ripple.client
-    @client.stub!(:backend).and_return(@backend)
     @bucket = Ripple.client.bucket("boxes")
     @plain = Riak::RObject.new(@bucket, "square"){|o| o.content_type = "application/json"; o.raw_data = '{"shape":"square"}'}
     @cb = Riak::RObject.new(@bucket, "rectangle"){|o| o.content_type = "application/json"; o.raw_data = '{"shape":"rectangle"}'}

data/spec/ripple/indexes_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Ripple::Indexes do
+  context "class methods" do
+    subject { Indexer }
+    it { should respond_to(:indexes) }
+    it { should have(4).indexes }
+
+    it "should remove the :index key from the property options" do
+      subject.properties[:name].options.should_not include(:index)
+      subject.properties[:age].options.should_not include(:index)
+    end
+
+    it "should not have a property for synthetic indexes" do
+      subject.properties[:name_age].should == nil
+      subject.properties[:name_greeting].should == nil
+    end
+  end
+  context "inherited indexes" do
+    subject { SubIndexer }
+    it { should have(5).indexes }
+    it "should have inherited indexes" do
+      subject.indexes.keys.should include('age', 'name', 'name_age', 'name_greeting')
+    end
+    it "should have indexes defined on the subclass" do
+      subject.indexes.keys.should include('height')
+    end
+  end
+
+  context "instance methods" do
+    before { subject.robject.stub!(:store).and_return(true) }
+    subject { Indexer.new(:name => "Bob", :age => 28) }
+    it { should respond_to(:indexes_for_persistence) }
+    its(:indexes_for_persistence) { should include('age_int') }
+    its(:indexes_for_persistence) { should include('name_bin') }
+    its(:indexes_for_persistence) { should include('name_age_bin') }
+    its(:indexes_for_persistence) { should include('name_greeting_bin') }
+    its(:indexes_for_persistence) { should be_all {|_,i| i.kind_of?(Set) } }
+
+    it "should set the indexes on the internal Riak object when saving" do
+      subject.save
+      subject.robject.indexes.should_not be_empty
+      subject.robject.indexes["name_bin"].should == Set["Bob"]
+      subject.robject.indexes["age_int"].should == Set[28]
+      subject.robject.indexes["name_age_bin"].should == Set["Bob-28"]
+      subject.robject.indexes["name_greeting_bin"].should == Set["Bob: Hello!"]
+    end
+
+    context "when embedded documents have indexes" do
+      subject do
+        Indexer.new(:name => "Bob",
+                    :age => 28,
+                    :addresses => [{:street => "10 Main St", :city => "Anywhere"},
+                                   {:street => "100 W 10th Avenue", :city => "Springfield"}],
+                    :primary_address => {
+                      :street => "1 W 5th Place",
+                      :city => "Independence"})
+      end
+
+      its(:indexes_for_persistence){ should include("primary_address_street_bin") }
+      its(:indexes_for_persistence){ should include("primary_address_city_bin") }
+      its(:indexes_for_persistence){ should include("addresses_street_bin") }
+      its(:indexes_for_persistence){ should include("addresses_city_bin") }
+
+      it "should merge indexes for many embedded associations" do
+        subject.indexes_for_persistence['addresses_city_bin'].should == Set["Anywhere", "Springfield"]
+        subject.indexes_for_persistence['addresses_street_bin'].should == Set["10 Main St", "100 W 10th Avenue"]
+      end
+    end
+  end
+end
+
+describe Ripple::Index do
+  it "should use a binary index when the type is a String" do
+    Ripple::Index.new('foo', String).index_type.should == 'bin'
+  end
+
+  it "should use an integer index when the type is an Integer" do
+    Ripple::Index.new('foo', Integer).index_type.should == 'int'
+  end
+
+  it "should use an integer index when the type is a time" do
+    [Time, Date, ActiveSupport::TimeWithZone].each do |klass|
+      Ripple::Index.new('foo', klass).index_type.should == 'int'
+    end
+  end
+
+  it "should use an integer index when index type is Integer" do
+    Ripple::Index.new('foo', String, Integer).index_type.should == 'int'
+  end
+
+  it "should use a binary index when index type is String" do
+    Ripple::Index.new('foo', Integer, String).index_type.should == 'bin'
+  end
+
+  it "should raise an error when the index type cannot be determined" do
+    klass = Class.new
+    expect { Ripple::Index.new('foo', klass).index_type }.to raise_error(ArgumentError)
+  end
+
+  it "should use the specified index type" do
+    Ripple::Index.new('foo', Time, 'bin').index_type.should == 'bin'
+    Ripple::Index.new('foo', Time, String).index_type.should == 'bin'
+    Ripple::Index.new('foo', Time, Integer).index_type.should == 'int'
+  end
+
+  it "should provide an index key that includes the type" do
+    Ripple::Index.new('foo', Integer).index_key.should == 'foo_int'
+    Ripple::Index.new('foo', String).index_key.should == 'foo_bin'
+  end
+end

data/spec/ripple/observable_spec.rb

@@ -6,8 +6,7 @@ describe Ripple::Observable do
 
   before :each do
     @client   = Ripple.client
-    @backend = mock("Backend", :store_object => true)
-    @client.stub!(:backend).and_return(@backend)
+    @client.stub(:store_object => true)
     @clock    = Clock.new
     @observer = ClockObserver.instance
   end

data/spec/ripple/persistence_spec.rb

@@ -4,9 +4,7 @@ describe Ripple::Document::Persistence do
   # require 'support/models/widget'
 
   before :each do
-    @backend = mock("Backend")
     @client = Ripple.client
-    @client.stub!(:backend).and_return(@backend)
     @bucket = Ripple.client.bucket("widgets")
     @widget = Widget.new(:size => 1000)
   end
@@ -14,7 +12,7 @@ describe Ripple::Document::Persistence do
   it "forces the content type to 'application/json'" do
     @widget.robject.content_type = 'application/not-json'
 
-    @backend.should_receive(:store_object) do |obj, *_|
+    @client.should_receive(:store_object) do |obj, *_|
       obj.content_type.should == 'application/json'
     end
 
@@ -22,9 +20,9 @@ describe Ripple::Document::Persistence do
   end
 
   it "should save a new object to Riak" do
-    json = @widget.attributes.merge("_type" => "Widget").to_json
-    @backend.should_receive(:store_object) do |obj, _, _, _|
-      obj.raw_data.should == json
+    json = @widget.attributes.merge("_type" => "Widget")
+    @client.should_receive(:store_object) do |obj, _, _, _|
+      obj.data.should == json
       obj.key.should be_nil
       # Simulate loading the response with the key
       obj.key = "new_widget"
@@ -36,9 +34,9 @@ describe Ripple::Document::Persistence do
   end
 
   it "should modify attributes and save a new object" do
-    json = @widget.attributes.merge("_type" => "Widget", "size" => 5).to_json
-    @backend.should_receive(:store_object) do |obj, _, _, _|
-      obj.raw_data.should == json
+    json = @widget.attributes.merge("_type" => "Widget", "size" => 5)
+    @client.should_receive(:store_object) do |obj, _, _, _|
+      obj.data.should == json
       obj.key.should be_nil
       # Simulate loading the response with the key
       obj.key = "new_widget"
@@ -50,9 +48,9 @@ describe Ripple::Document::Persistence do
   end
 
   it "should modify a single attribute and save a new object" do
-    json = @widget.attributes.merge("_type" => "Widget", "size" => 5).to_json
-    @backend.should_receive(:store_object) do |obj, _, _, _|
-      obj.raw_data.should == json
+    json = @widget.attributes.merge("_type" => "Widget", "size" => 5)
+    @client.should_receive(:store_object) do |obj, _, _, _|
+      obj.data.should == json
       obj.key.should be_nil
       # Simulate loading the response with the key
       obj.key = "new_widget"
@@ -65,10 +63,10 @@ describe Ripple::Document::Persistence do
   end
 
   it "should instantiate and save a new object to riak" do
-    json = @widget.attributes.merge(:size => 10, :shipped_at => "2000-01-01T20:15:01Z", :_type => 'Widget').to_json
-    @backend.should_receive(:store_object) do |obj, _, _, _|
-      obj.raw_data.should == json
+    json = @widget.attributes.merge(:size => 10, :shipped_at => Time.utc(2000,"jan",1,20,15,1), :_type => 'Widget')
+    @client.should_receive(:store_object) do |obj, _, _, _|
       obj.key.should be_nil
+      obj.data.should == json
       # Simulate loading the response with the key
       obj.key = "new_widget"
     end
@@ -79,9 +77,9 @@ describe Ripple::Document::Persistence do
   end
 
   it "should instantiate and save a new object to riak and allow its attributes to be set via a block" do
-    json = @widget.attributes.merge(:size => 10, :_type => 'Widget').to_json
-    @backend.should_receive(:store_object) do |obj, _, _, _|
-      obj.raw_data.should == json
+    json = @widget.attributes.merge(:size => 10, :_type => 'Widget')
+    @client.should_receive(:store_object) do |obj, _, _, _|
+      obj.data.should == json
       obj.key.should be_nil
       # Simulate loading the response with the key
       obj.key = "new_widget"
@@ -95,7 +93,7 @@ describe Ripple::Document::Persistence do
 
   it "should save the attributes not having a corresponding property" do
     attrs = @widget.attributes.merge("_type" => "Widget", "unknown_property" => "a_value")
-    @backend.should_receive(:store_object) do |obj, _, _, _|
+    @client.should_receive(:store_object) do |obj, _, _, _|
       obj.data.should == attrs
       obj.key.should be_nil
       # Simulate loading the response with the key
@@ -109,22 +107,22 @@ describe Ripple::Document::Persistence do
   end
 
   it "should allow unexpected exceptions to be raised" do
-    robject = mock("robject", :key => @widget.key, "data=" => true, "content_type=" => true)
+    robject = mock("robject", :key => @widget.key, "data=" => true, "content_type=" => true, "indexes=" => true)
     robject.should_receive(:store).and_raise(Riak::HTTPFailedRequest.new(:post, 200, 404, {}, "404 not found"))
     @widget.stub!(:robject).and_return(robject)
     lambda { @widget.save }.should raise_error(Riak::FailedRequest)
   end
 
   it "should reload a saved object, including associations" do
-    json = @widget.attributes.merge(:_type => "Widget").to_json
-    @backend.should_receive(:store_object) do |obj, _, _, _|
-      obj.raw_data.should == json
+    json = @widget.attributes.merge(:_type => "Widget")
+    @client.should_receive(:store_object) do |obj, _, _, _|
+      obj.data.should == json
       obj.key.should be_nil
       # Simulate loading the response with the key
       obj.key = "new_widget"
     end
     @widget.save
-    @backend.should_receive(:reload_object) do |obj, _|
+    @client.should_receive(:reload_object) do |obj, _|
       obj.key.should == "new_widget"
       obj.content_type = 'application/json'
       obj.raw_data = '{"name":"spring","size":10,"shipped_at":"Sat, 01 Jan 2000 20:15:01 -0000","_type":"Widget"}'
@@ -140,13 +138,14 @@ describe Ripple::Document::Persistence do
   end
 
   it "should destroy a saved object" do
-    @backend.should_receive(:store_object).and_return(true)
+    @client.should_receive(:store_object).and_return(true)
     @widget.key = "foo"
     @widget.save
     @widget.should_not be_new
-    @backend.should_receive(:delete_object).and_return(true)
+    @client.should_receive(:delete_object).and_return(true)
     @widget.destroy.should be_true
     @widget.should be_frozen
+    @widget.should be_deleted
   end
 
   it "should destroy all saved objects" do
@@ -155,10 +154,34 @@ describe Ripple::Document::Persistence do
     Widget.destroy_all.should be_true
   end
 
+  context 'when a delete fails' do
+    let(:error) { Riak::FailedRequest.new("Riak could not delete your object") }
+    before(:each) do
+      @widget.stub(:new? => false)
+      @widget.robject.should_receive(:delete).and_raise(error)
+    end
+
+    it 'causes destroy to return false' do
+      @widget.destroy.should be_false
+    end
+
+    it 'causes destroy! to raise an error' do
+      expect {
+        @widget.destroy!
+      }.to raise_error(Riak::FailedRequest)
+    end
+  end
+
   it "should freeze an unsaved object when destroying" do
-    @backend.should_not_receive(:delete_object)
+    @client.should_not_receive(:delete_object)
+    @widget.destroy.should be_true
+    @widget.should be_frozen
+  end
+
+  it "should be able to call #errors after destroying" do
     @widget.destroy.should be_true
     @widget.should be_frozen
+    expect { @widget.errors }.to_not raise_error
   end
 
   it "should be a root document" do
@@ -171,9 +194,9 @@ describe Ripple::Document::Persistence do
     end
 
     it "should store the _type field as the class name" do
-      json = @cog.attributes.merge("_type" => "Cog").to_json
-      @backend.should_receive(:store_object) do |obj, _, _, _|
-        obj.raw_data.should == json
+      json = @cog.attributes.merge("_type" => "Cog")
+      @client.should_receive(:store_object) do |obj, _, _, _|
+        obj.data.should == json
         obj.key = "new_widget"
       end
       @cog.save
@@ -213,7 +236,7 @@ describe Ripple::Document::Persistence do
 
   shared_examples_for "saving a parent document with linked child documents" do
     before(:each) do
-      @backend.stub(:store_object)
+      @client.stub(:store_object)
     end
 
     it 'saves new children when the parent is saved' do
@@ -279,7 +302,7 @@ describe Ripple::Document::Persistence do
 
   shared_examples_for "embedded association persistence logic" do
     before(:each) do
-      @backend.stub(:store_object)
+      @client.stub(:store_object)
     end
 
     it "does not save children when the parent is saved" do