ripple 1.0.0.beta → 1.0.0.beta2

data/spec/generators/ripple_generator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'rails/generators/ripple_generator'
+
+describe RippleGenerator do
+  it "should invoke the sub-generators" do
+    %w{configuration js test}.each do |gen|
+      generator.should_receive(:invoke).with("ripple:#{gen}")
+    end
+    run_generator
+  end
+end

data/spec/integration/ripple/conflict_resolution_spec.rb

@@ -37,11 +37,8 @@ describe "Ripple conflict resolution", :integration => true do
     property :title, String
   end
 
-  before :all do
-    ConflictedPerson.bucket.allow_mult = true
-  end
-
   before(:each) do
+    ConflictedPerson.bucket.allow_mult ||= true
     ConflictedPerson.on_conflict { } # reset to no-op
   end
 
@@ -76,6 +73,40 @@ describe "Ripple conflict resolution", :integration => true do
                              )
   end
 
+  context 'for a document that has a deleted sibling' do
+    before(:each) do
+      create_conflict original_person,
+        lambda { |p| p.destroy! },
+        lambda { |p| p.age = 20 },
+        lambda { |p| p.age = 30 }
+    end
+
+    it 'indicates that one of the siblings was deleted' do
+      siblings = nil
+      ConflictedPerson.on_conflict { |s, c| siblings = s }
+      ConflictedPerson.find('John')
+
+      siblings.should have(3).sibling_records
+      deleted, undeleted = siblings.partition(&:deleted?)
+      deleted.should have(1).record
+      undeleted.should have(2).records
+      deleted = deleted.first
+
+      # the deleted record should be totally blank except for the name (since it is the key)
+      deleted.attributes.reject { |k, v| v.blank? }.should == {"name" => "John"}
+    end
+
+    it 'does not consider the deleted sibling when trying basic resolution of attributes that siblings are in agreement about' do
+      record = conflicts = nil
+      ConflictedPerson.on_conflict { |s, c| conflicts = c; record = self }
+      ConflictedPerson.find('John')
+
+      conflicts.should == [:age]
+      record.gender.should == 'male'
+      record.favorite_colors.should == ['green'].to_set
+    end
+  end
+
   context 'for a document that has conflicted attributes' do
     let(:most_recent_updated_at) { DateTime.new(2011, 6, 4, 12, 30) }
     let(:earliest_created_at)    { DateTime.new(2010, 5, 3, 12, 30) }

data/spec/integration/ripple/indexes_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Ripple::Indexes do
+  context "finding documents by an index" do
+    before do
+      @bob = Indexer.create(:name => "Bob", :age => 28)
+      @sally = Indexer.create(:name => "Sally", :age => 28)
+      @mary = Indexer.create(:name => "Mary", :age => 25)
+    end
+
+    it "should find a document by equality" do
+      Indexer.find_by_index(:name, 'Bob').should == [@bob]
+    end
+
+    it "should find many documents by equality" do
+      Indexer.find_by_index(:age, 28).should =~ [@bob, @sally]
+    end
+
+    it "should find nothing by equality" do
+      Indexer.find_by_index(:age, 30).should == []
+    end
+
+    it "should find a document by range" do
+      Indexer.find_by_index(:name, "B".."C").should == [@bob]
+    end
+
+    it "should find many documents by range" do
+      Indexer.find_by_index(:age, 27..29).should =~ [@bob, @sally]
+    end
+
+    it "should find nothing by range" do
+      Indexer.find_by_index(:age, 10..20).should == []
+    end
+
+    it "should find by the special $bucket index" do
+      Indexer.find_by_index('$bucket', Indexer.bucket.name).should =~ [@bob, @sally, @mary]
+    end
+
+    it "should find by the special $key index" do
+      Indexer.find_by_index('$key', @bob.key..@bob.key.succ).should =~ [@bob]
+    end
+
+    it "should raise an error when the requested index doesn't exist" do
+      lambda { Indexer.find_by_index(:hair, 'blonde') }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/ripple/associations/many_embedded_proxy_spec.rb

@@ -1,122 +1,112 @@
 require 'spec_helper'
 
 describe Ripple::Associations::ManyEmbeddedProxy do
-  # require 'support/models/user'
-  # require 'support/models/address'
-  # require 'support/models/note'
-
-  before :each do
-    @user    = User.new(:email => "riak@ripple.com")
-    @address = Address.new
-    @addr    = Address.new(:street => '123 Somewhere')
-    @note    = Note.new
-  end
+  let(:user){ User.new(:email => "riak@ripple.com") }
+  let(:address){ Address.new }
+  let(:addr){ Address.new(:street => '123 Somewhere') }
+  let(:note){ Note.new }
 
   it "should not have children before any are set" do
-    @user.addresses.should == []
+    user.addresses.should == []
   end
 
   it "should be able to set and get its children" do
-    Address.stub!(:instantiate).and_return(@address)
-    @user.addresses = [@address]
-    @user.addresses.should == [@address]
+    user.addresses = [address]
+    user.addresses.should == [address]
   end
 
   it "should set the parent document on the children when assigning" do
-    @user.addresses = [@address]
-    @address._parent_document.should == @user
+    user.addresses = [address]
+    address._parent_document.should == user
   end
 
   it "should return the assignment when assigning" do
-    rtn = @user.addresses = [@address]
-    rtn.should == [@address]
+    rtn = user.addresses = [address]
+    rtn.should == [address]
   end
 
   it "should set the parent document on the children when accessing" do
-    @user.addresses = [@address]
-    @user.addresses.first._parent_document.should == @user
+    user.addresses = [address]
+    user.addresses.first._parent_document.should == user
   end
 
   it "should be able to replace its children with different children" do
-    @user.addresses = [@address]
-    @user.addresses.first.street.should be_blank
-    @user.addresses = [@addr]
-    @user.addresses.first.street.should == '123 Somewhere'
+    user.addresses = [address]
+    user.addresses.first.street.should be_blank
+    user.addresses = [addr]
+    user.addresses.first.street.should == '123 Somewhere'
   end
 
   it "should be able to add to its children" do
-    Address.stub!(:instantiate).and_return(@address)
-    @user.addresses = [@address]
-    @user.addresses << @address
-    @user.addresses.should == [@address, @address]
+    user.addresses = [address]
+    user.addresses << addr
+    user.addresses.should == [address, addr]
   end
 
   it "should be able to chain calls to adding children" do
-    Address.stub!(:instantiate).and_return(@address)
-    @user.addresses = [@address]
-    @user.addresses << @address << @address << @address
-    @user.addresses.should == [@address, @address, @address, @address]
+    user.addresses = [address]
+    user.addresses << address << address << address
+    user.addresses.should == [address, address, address, address]
   end
 
   it "should set the parent document when adding to its children" do
-    @user.addresses << @address
-    @user.addresses.first._parent_document.should == @user
+    user.addresses << address
+    user.addresses.first._parent_document.should == user
   end
 
   it "should be able to count its children" do
-    @user.addresses = [@address, @address]
-    @user.addresses.count.should == 2
+    user.addresses = [address, address]
+    user.addresses.count.should == 2
   end
 
   it "should be able to build a new child" do
-    Address.stub!(:new).and_return(@address)
-    @user.addresses.build.should == @address
+    user.addresses.build.should be_kind_of(Address)
   end
 
   it "should assign a parent to the children created with instantiate_target" do
-    Address.stub!(:new).and_return(@address)
-    @address._parent_document.should be_nil
-    @user.addresses.build._parent_document.should == @user
+    address._parent_document.should be_nil
+    user.addresses.build._parent_document.should == user
   end
 
   it "should validate the children when saving the parent" do
-    @user.valid?.should be_true
-    @user.addresses << @address
-    @address.valid?.should be_false
-    @user.valid?.should be_false
+    user.valid?.should be_true
+    user.addresses << address
+    address.valid?.should be_false
+    user.valid?.should be_false
   end
 
   it "should not save the root document when a child is invalid" do
-    @user.addresses << @address
-    @user.save.should be_false
+    user.addresses << address
+    user.save.should be_false
   end
 
   it "should allow embedding documents in embedded documents" do
-    @user.addresses << @address
-    @address.notes << @note
-    @note._root_document.should   == @user
-    @note._parent_document.should == @address
+    user.addresses << address
+    address.notes << note
+    note._root_document.should   == user
+    note._parent_document.should == address
   end
 
   it "should allow assiging child documents as an array of hashes" do
-    @user.attributes = {'addresses' => [{'street' => '123 Somewhere'}]}
-    @user.addresses.first.street.should == '123 Somewhere'
+    user.attributes = {'addresses' => [{'street' => '123 Somewhere'}]}
+    user.addresses.first.street.should == '123 Somewhere'
   end
 
   it "should return an array from to_ary" do
-    Address.stub!(:instantiate).and_return(@address)
-    @user.addresses << @address
-    @user.addresses.to_ary.should == [@address]
+    user.addresses << address
+    user.addresses.to_ary.should == [address]
   end
 
   it "should refuse assigning documents of the wrong type" do
-    lambda { @user.addresses = nil }.should raise_error
-    lambda { @user.addresses = @address }.should raise_error
-    lambda { @user.addresses = [@note] }.should raise_error
+    lambda { user.addresses = nil }.should raise_error
+    lambda { user.addresses = address }.should raise_error
+    lambda { user.addresses = [note] }.should raise_error
   end
 
   it "should not add the associated validator multiple times" do
-    #$stderr.puts User.validators.collect(&:inspect)
+    # TODO: the validator is added lazily on first instantiation of
+    # the proxy. This is a code smell!
+    user.addresses 
     User.validators_on(:addresses).count.should eq(1)
   end
 end

data/spec/ripple/associations/many_linked_proxy_spec.rb

@@ -58,7 +58,7 @@ describe Ripple::Associations::ManyLinkedProxy do
     @person.tasks.__send__(:should_receive, :reset)
     @person.tasks.__send__(:links).should == [@task.robject.to_link("tasks")]
     @person.tasks.replace_links([@other_task, @third_task].map { |t| t.robject.to_link("tasks") })
-    @person.tasks.__send__(:links).should == [@other_task, @third_task].map { |t| t.robject.to_link("tasks") }
+    @person.tasks.__send__(:links).should =~ [@other_task, @third_task].map { |t| t.robject.to_link("tasks") }
   end
 
   it "should replace associated documents with a new set" do
@@ -151,7 +151,7 @@ describe Ripple::Associations::ManyLinkedProxy do
 
     it "returns a set of keys" do
       @person.tasks.keys.should be_a(Set)
-      @person.tasks.keys.to_a.should == link_keys
+      @person.tasks.keys.to_a.should =~ link_keys
     end
 
     it "is memoized between calls" do

data/spec/ripple/associations/many_reference_proxy_spec.rb

@@ -123,7 +123,7 @@ describe Ripple::Associations::ManyReferenceProxy do
 
     it "returns a set of keys" do
       @account.payment_methods.keys.should be_a(Set)
-      @account.payment_methods.keys.to_a.should == ze_keys
+      @account.payment_methods.keys.to_a.should =~ ze_keys
     end
 
     it "is memoized between calls" do

data/spec/ripple/associations_spec.rb

@@ -11,22 +11,23 @@ describe Ripple::Associations do
   end
 
   it "should collect the embedded associations" do
-    Invoice.embedded_associations.should == Array(Invoice.associations[:note])
+    Invoice.embedded_associations.should == [ Invoice.associations[:note] ]
   end
 
   it "should collect the linked associations" do
-    Invoice.linked_associations.should == Array(Invoice.associations[:customer])
+    Invoice.linked_associations.should == [ Invoice.associations[:customer] ]
   end
 
   it "should collect the stored_key associations" do
-    Account.stored_key_associations.should == Array(Account.associations[:transactions])
-    Transaction.stored_key_associations.should == Array(Transaction.associations[:account])
+    Account.stored_key_associations.should == [ Account.associations[:transactions] ]
+    Transaction.stored_key_associations.should == [ Transaction.associations[:account] ]
   end
 
   it "should copy associations to a subclass" do
     Invoice.associations[:foo] = "bar"
     class SubInvoice < Invoice; end
     SubInvoice.associations[:foo].should == "bar"
+    Invoice.associations.delete :foo
   end
 
   describe "when adding a :many association" do
@@ -128,9 +129,6 @@ describe Ripple::Association do
   end
 
   describe "key correspondence" do
-    require 'support/models/profile'
-    require 'support/models/user'
-
     it "should raise an exception if trying to use a many association when :using => :key" do
       expect { Profile.many :user, :using => :key }.to raise_error(ArgumentError, "You cannot use a many association using :key")
     end
@@ -141,4 +139,15 @@ describe Ripple::Association do
       Profile.new.should respond_to(:key_delegate=)
     end
   end
+
+  describe "stored key" do
+    it "should raise an error when the target property does not exist" do
+      expect {
+        Class.new do
+          include Ripple::Document
+          many :transactions, :using => :stored_key
+        end
+      }.to raise_error(ArgumentError)
+    end
+  end
 end

data/spec/ripple/attribute_methods_spec.rb

@@ -140,7 +140,7 @@ describe Ripple::AttributeMethods do
 
   describe "#attributes" do
     it "it returns a hash representation of all of the attributes" do
-      @widget.attributes.should == {"name" => "widget", "size" => nil, "manufactured" => false, "shipped_at" => nil}
+      @widget.attributes.should == {"name" => "widget", "size" => nil, "manufactured" => false, "shipped_at" => nil, "restricted" => false}
     end
 
     it "does not include ghost attributes (attributes that do not have a defined property)" do
@@ -157,7 +157,8 @@ describe Ripple::AttributeMethods do
         'size'                => nil,
         'manufactured'        => false,
         'shipped_at'          => nil,
-        'some_undefined_prop' => 17
+        'some_undefined_prop' => 17,
+        'restricted'          => false,
       }
     end
   end
@@ -227,4 +228,44 @@ describe Ripple::AttributeMethods do
     lambda { @widget = Widget.new(:explode => '?BOOM') }.should raise_error(ArgumentError, %q[Undefined property :explode for class 'Widget'])
   end
 
+  it "should allow mass assigning arbitrary attributes when without_protection is specified" do
+    @widget = Widget.new({:manufactured => true}, :without_protection => true)
+    @widget[:manufactured].should be_true
+
+    @client = Ripple.client
+    @client.stub(:store_object => true)
+
+    @widget = Widget.create({:manufactured => true}, :without_protection => true)
+    @widget[:manufactured].should be_true
+
+    @widget = Widget.create!({:manufactured => true}, :without_protection => true)
+    @widget[:manufactured].should be_true
+  end
+
+  it "default assign_attributes should respect mass attribute assignment security" do
+    @widget = Widget.new
+    @widget.assign_attributes(:manufactured => true)
+    @widget.manufactured.should be_false
+  end
+
+  if(ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
+    it "assigning attributes should respect roles" do
+      @widget = Widget.new
+      @widget.assign_attributes(:restricted => true)
+      @widget.restricted.should be_false
+
+      lambda do
+        @widget.assign_attributes({:restricted => true}, :as => :admin)
+      end.should raise_error(ArgumentError, %q[Roles for mass assignment are not supported for Rails 3.0])
+    end
+  else
+    it "assigning attributes with a role should raise an error" do
+      @widget = Widget.new
+      @widget.assign_attributes(:restricted => true)
+      @widget.restricted.should be_false
+
+      @widget.assign_attributes({:restricted => true}, :as => :admin)
+      @widget.restricted.should be_true
+    end
+  end
 end

data/spec/ripple/callbacks_spec.rb

@@ -1,175 +1,194 @@
 require 'spec_helper'
 
 describe Ripple::Callbacks do
-  # require 'support/models/box'
+  let(:doc) do
+    _e = embedded
+    Class.new do
+      include Ripple::Document
+      self.bucket_name = "docs"
+      many :embeddeds, :class => _e
+    end
+  end
+
+  let(:embedded) do
+    Class.new do
+      include Ripple::EmbeddedDocument
+    end
+  end
+
+  subject { doc.new }
 
   it "should add create, update, save, and destroy callback declarations" do
     [:save, :create, :update, :destroy].each do |event|
-      Box.private_instance_methods.map(&:to_s).should include("_run_#{event}_callbacks")
+      doc.private_instance_methods.map(&:to_s).should include("_run_#{event}_callbacks")
       [:before, :after, :around].each do |time|
-        Box.should respond_to("#{time}_#{event}")
+        doc.should respond_to("#{time}_#{event}")
       end
     end
   end
 
   it "should validate callback declarations" do
-    Box.private_instance_methods.map(&:to_s).should include("_run_validation_callbacks")
-    Box.should respond_to("before_validation")
-    Box.should respond_to("after_validation")
+    doc.private_instance_methods.map(&:to_s).should include("_run_validation_callbacks")
+    doc.should respond_to("before_validation")
+    doc.should respond_to("after_validation")
   end
 
   describe "invoking callbacks" do
     before :each do
-      response = {:headers => {"content-type" => ["application/json"]}, :body => "{}"}
       @client = Ripple.client
-      @backend = mock("Backend", :store_object => true)
-      @client.stub!(:backend).and_return(@backend)
-      $pinger = mock("callback verifier")
+      @client.stub(:store_object => true)
     end
 
     it "should call save callbacks on save" do
-      Box.before_save { $pinger.ping }
-      Box.after_save { $pinger.ping }
-      Box.around_save(lambda { $pinger.ping })
-      $pinger.should_receive(:ping).exactly(3).times
-      @box = Box.new
-      @box.save
+      callbacks = []
+      doc.before_save { callbacks << :before }
+      doc.after_save { callbacks << :after }
+      doc.around_save(lambda { callbacks << :around })
+      subject.save
+      callbacks.should == [ :before, :around, :after ]
     end
 
     it "propagates callbacks to embedded associated documents" do
-      Box.before_save { $pinger.ping }
-      BoxSide.before_save { $pinger.ping }
-      $pinger.should_receive(:ping).exactly(2).times
-      @box = Box.new
-      @box.sides << BoxSide.new
-      @box.save
+      callbacks = []
+      doc.before_save { callbacks << :box }
+      embedded.before_save { callbacks << :side }
+      subject.embeddeds << embedded.new
+      subject.save
+      callbacks.should == [:side, :box]
     end
 
     it 'does not persist the object to riak multiple times when propagating callbacks' do
-      Box.before_save { }
-      BoxSide.before_save { }
-      @box = Box.new
-      @box.sides << BoxSide.new << BoxSide.new
+      doc.before_save { }
+      embedded.before_save { }
+      subject.embeddeds << embedded.new << embedded.new
 
-      @box.robject.should_receive(:store).once
-      @box.save
+      subject.robject.should_receive(:store).once
+      subject.save
     end
 
     it 'invokes the before/after callbacks in the correct order on embedded associated documents' do
       callbacks = []
-      BoxSide.before_save { callbacks << :before_save }
-      BoxSide.after_save  { callbacks << :after_save  }
+      embedded.before_save { callbacks << :before_save }
+      embedded.after_save  { callbacks << :after_save  }
 
-      @box = Box.new
-      @box.sides << BoxSide.new
-      @box.robject.stub(:store) do
+      subject.embeddeds << embedded.new
+      subject.robject.stub(:store) do
         callbacks << :save
       end
-      @box.save
+      subject.save
 
       callbacks.should == [:before_save, :save, :after_save]
     end
 
     it 'does not allow around callbacks on embedded associated documents' do
       expect {
-        BoxSide.around_save { }
+        embedded.around_save { }
       }.to raise_error(/around_save callbacks are not supported/)
     end
 
     it 'does not propagate validation callbacks multiple times' do
-      Box.before_validation { $pinger.ping }
-      BoxSide.before_validation { $pinger.ping }
-      $pinger.should_receive(:ping).exactly(2).times
-      @box = Box.new
-      @box.sides << BoxSide.new
-      @box.valid?
+      callbacks = []
+      doc.before_validation { callbacks << :box }
+      embedded.before_validation { callbacks << :side }
+
+      subject.embeddeds << embedded.new
+      subject.valid?
+      callbacks.should == [:box, :side]
     end
 
     it "should call create callbacks on save when the document is new" do
-      Box.before_create { $pinger.ping }
-      Box.after_create { $pinger.ping }
-      Box.around_create(lambda { $pinger.ping })
-      $pinger.should_receive(:ping).exactly(3).times
-      @box = Box.new
-      @box.save
+      callbacks = []
+      doc.before_create { callbacks << :before }
+      doc.after_create { callbacks << :after }
+      doc.around_create(lambda { callbacks << :around })
+
+      subject.save
+      callbacks.should == [:before, :around, :after ]
     end
 
     it "should call update callbacks on save when the document is not new" do
-      Box.before_update { $pinger.ping }
-      Box.after_update { $pinger.ping }
-      Box.around_update(lambda { $pinger.ping })
-      $pinger.should_receive(:ping).exactly(3).times
-      @box = Box.new
-      @box.stub!(:new?).and_return(false)
-      @box.save
+      callbacks = []
+      doc.before_update { callbacks << :before }
+      doc.after_update { callbacks << :after }
+      doc.around_update(lambda { callbacks << :around })
+
+      subject.stub!(:new?).and_return(false)
+      subject.save
+      callbacks.should == [:before, :around, :after ]
     end
 
-    it "should call destroy callbacks" do
-      Box.before_destroy { $pinger.ping }
-      Box.after_destroy { $pinger.ping }
-      Box.around_destroy(lambda { $pinger.ping })
-      $pinger.should_receive(:ping).exactly(3).times
-      @box = Box.new
-      @box.destroy
+    describe "destroy callbacks" do
+      let(:callbacks) { [] }
+
+      before(:each) do
+        _callbacks = callbacks
+        doc.before_destroy { _callbacks << :before }
+        doc.after_destroy { _callbacks << :after }
+        doc.around_destroy(lambda { _callbacks << :around })
+      end
+
+      after { callbacks.should == [ :before, :around, :after ] }
+
+      it "invokes them when #destroy is called" do
+        subject.destroy
+      end
+
+      it "invokes them when #destroy! is called" do
+        subject.destroy!
+      end
     end
 
     it "should call save and validate callbacks in the correct order" do
-      Box.before_validation { $pinger.ping(:v) }
-      Box.before_save { $pinger.ping(:s) }
-      $pinger.should_receive(:ping).with(:v).ordered
-      $pinger.should_receive(:ping).with(:s).ordered
-      @box = Box.new
-      @box.save
+      callbacks = []
+      doc.before_validation { callbacks << :validation }
+      doc.before_save { callbacks << :save }
+
+      subject.save
+      callbacks.should == [:validation, :save]
     end
 
     describe "validation callbacks" do
       it "should call validation callbacks" do
-        Box.before_validation { $pinger.ping }
-        Box.after_validation  { $pinger.ping }
-        $pinger.should_receive(:ping).twice
-        @box = Box.new
-        @box.valid?
+        callbacks = []
+        doc.before_validation { callbacks << :before }
+        doc.after_validation  { callbacks << :after }
+        subject.valid?
+        callbacks.should == [:before, :after]
       end
 
       it "should call validation callbacks only if the document is new" do
-        Box.before_validation(:on => :create) { $pinger.ping }
-        Box.after_validation(:on => :create) { $pinger.ping }
-        $pinger.should_receive(:ping).twice
-        @box = Box.new
-        @box.valid?
+        callbacks = []
+        doc.before_validation(:on => :create) { callbacks << :before }
+        doc.after_validation(:on => :create) { callbacks << :after }
+        subject.valid?
+        callbacks.should == [:before, :after]
       end
 
       it "should not call validation callbacks only if the document is new" do
-        Box.before_validation(:on => :update) { $pinger.ping }
-        Box.after_validation(:on => :update) { $pinger.ping }
-        $pinger.should_not_receive(:ping)
-        @box = Box.new
-        @box.valid?
+        callbacks = []
+        doc.before_validation(:on => :update) { callbacks << :before }
+        doc.after_validation(:on => :update) { callbacks << :after }
+        subject.valid?
+        callbacks.should be_empty
       end
 
       it "should call validation callbacks only if the document is not new" do
-        Box.before_validation(:on => :update) { $pinger.ping }
-        Box.after_validation(:on => :update) { $pinger.ping }
-        $pinger.should_receive(:ping).twice
-        @box = Box.new
-        @box.stub(:new?).and_return(false)
-        @box.valid?
-      end
+        callbacks = []
+        doc.before_validation(:on => :update) { callbacks << :before }
+        doc.after_validation(:on => :update) { callbacks << :after }
 
-      it "should not call validation callbacks only if the document is not new" do
-        Box.before_validation(:on => :create) { $pinger.ping }
-        Box.after_validation(:on => :create) { $pinger.ping }
-        $pinger.should_not_receive(:ping)
-        @box = Box.new
-        @box.stub!(:new?).and_return(false)
-        @box.valid?
+        subject.stub(:new?).and_return(false)
+        subject.valid?
+        callbacks.should == [:before, :after]
       end
-    end
 
-    after :each do
-      [:save, :create, :update, :destroy, :validation].each do |type|
-        Box.reset_callbacks(type)
-        BoxSide.reset_callbacks(type)
+      it "should not call validation callbacks only if the document is not new" do
+        callbacks = []
+        doc.before_validation(:on => :create) { callbacks << :validation }
+        doc.after_validation(:on => :create) { callbacks << :after }
+        subject.stub!(:new?).and_return(false)
+        subject.valid?
+        callbacks.should be_empty
       end
     end
   end