jchupp-is_paranoid 0.7.0 → 0.7.1

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 7
-:patch: 0
+:patch: 1

data/spec/is_paranoid_spec.rb

@@ -1,33 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/models')
 
-class Person < ActiveRecord::Base #:nodoc:
-  validates_uniqueness_of :name
-  has_many :androids, :foreign_key => :owner_id, :dependent => :destroy
-end
-
-class Android < ActiveRecord::Base #:nodoc:
-  validates_uniqueness_of :name
-  has_many :components, :dependent => :destroy
-
-  is_paranoid
-
-  before_update :raise_hell
-  def raise_hell
-    raise "hell"
-  end
-end
-
-class Component < ActiveRecord::Base #:nodoc:
-  is_paranoid
-end
-
-class AndroidWithScopedUniqueness < ActiveRecord::Base #:nodoc:
-  set_table_name :androids
-  validates_uniqueness_of :name, :scope => :deleted_at
-  is_paranoid
-end
-
-describe Android do
+describe IsParanoid do
   before(:each) do
     Android.delete_all
     Person.delete_all
@@ -39,169 +13,194 @@ describe Android do
     @r2d2.components.create(:name => 'Rotors')
   end
 
-  it "should delete normally" do
-    Android.count_with_destroyed.should == 2
-    Android.delete_all
-    Android.count_with_destroyed.should == 0
-  end
-
-  it "should handle Model.destroy_all properly" do
-    lambda{
-      Android.destroy_all("owner_id = #{@luke.id}")
-    }.should change(Android, :count).from(2).to(0)
-    Android.count_with_destroyed.should == 2
-  end
-
-  it "should handle Model.destroy(id) properly without hitting update/save related callbacks" do
-    lambda{
-      Android.destroy(@r2d2.id)
-    }.should change(Android, :count).from(2).to(1)
-
-    Android.count_with_destroyed.should == 2
-  end
-
-  it "should be not show up in the relationship to the owner once deleted" do
-    @luke.androids.size.should == 2
-    @r2d2.destroy
-    @luke.androids.size.should == 1
-    Android.count.should == 1
-    Android.first(:conditions => {:name => 'R2D2'}).should be_blank
-  end
-
-  it "should be able to find deleted items via find_with_destroyed" do
-    @r2d2.destroy
-    Android.find(:first, :conditions => {:name => 'R2D2'}).should be_blank
-    Android.first_with_destroyed(:conditions => {:name => 'R2D2'}).should_not be_blank
-  end
-
-  it "should be able to find only deleted items via find_destroyed_only" do
-    @r2d2.destroy
-    Android.all_destroyed_only.size.should == 1
-    Android.first_destroyed_only.should == @r2d2
-  end
-
-  it "should have a proper count inclusively and exclusively of deleted items" do
-    @r2d2.destroy
-    @c3p0.destroy
-    Android.count.should == 0
-    Android.count_with_destroyed.should == 2
-  end
-
-  it "should mark deleted on dependent destroys" do
-    lambda{
-      @luke.destroy
-    }.should change(Android, :count).from(2).to(0)
-    Android.count_with_destroyed.should == 2
-  end
-
-  it "should allow restoring without hitting update/save related callbacks" do
-    @r2d2.destroy
-    lambda{
-      @r2d2.restore
-    }.should change(Android, :count).from(1).to(2)
-  end
-
-  it "should restore dependent models when being restored" do
-    @r2d2.destroy
-    lambda{
-      @r2d2.restore
-    }.should change(Component, :count).from(0).to(1)
-  end
-
-  it "should allow the option to not restore dependent models when being restored" do
-    @r2d2.destroy
-    lambda{
-      @r2d2.restore(:include_destroyed_dependents => false)
-    }.should_not change(Component, :count)
-  end
-
-  it "should respond to various calculations" do
-    @r2d2.destroy
-    Android.sum('id').should == @c3p0.id
-    Android.sum_with_destroyed('id').should == @r2d2.id + @c3p0.id
-
-    Android.average_with_destroyed('id').should == (@r2d2.id + @c3p0.id) / 2.0
-  end
-
-  it "should not ignore deleted items in validation checks unless scoped" do
-    # Androids are not validates_uniqueness_of scoped
-    @r2d2.destroy
-    lambda{
-      Android.create!(:name => 'R2D2')
-    }.should raise_error(ActiveRecord::RecordInvalid)
-
-    lambda{
-      # creating shouldn't raise an error
-      another_r2d2 = AndroidWithScopedUniqueness.create!(:name => 'R2D2')
-      # neither should destroying the second incarnation since the
-      # validates_uniqueness_of is only applied on create
-      another_r2d2.destroy
-    }.should_not raise_error
-  end
-end
-
-class Ninja < ActiveRecord::Base #:nodoc:
-  validates_uniqueness_of :name, :scope => :visible
-  is_paranoid :field => [:visible, false, true]
-end
-
-class Pirate < ActiveRecord::Base #:nodoc:
-  is_paranoid :field => [:alive, false, true]
-end
-
-class DeadPirate < ActiveRecord::Base #:nodoc:
-  set_table_name :pirates
-  is_paranoid :field => [:alive, true, false]
-end
-
-class RandomPirate < ActiveRecord::Base #:nodoc:
-  set_table_name :pirates
-
-  def after_destroy
-    raise 'after_destroy works'
-  end
-end
-
-class UndestroyablePirate < ActiveRecord::Base #:nodoc:
-  set_table_name :pirates
-  is_paranoid :field => [:alive, false, true]
-
-  def before_destroy
-    false
-  end
-end
-
-describe 'Ninjas and Pirates' do
-  it "should allow specifying alternate fields and field values" do
-    ninja = Ninja.create(:name => 'Esteban')
-    ninja.destroy
-    Ninja.first.should be_blank
-    Ninja.find_with_destroyed(:first).should == ninja
-
-    pirate = Pirate.create(:name => 'Reginald')
-    pirate.destroy
-    Pirate.first.should be_blank
-    Pirate.find_with_destroyed(:first).should == pirate
-
-    DeadPirate.first.id.should == pirate.id
-    lambda{
-      DeadPirate.first.destroy
-    }.should change(Pirate, :count).from(0).to(1)
-  end
+  describe 'destroying' do
+    it "should soft-delete a record" do
+       lambda{
+         Android.destroy(@r2d2.id)
+       }.should change(Android, :count).from(2).to(1)
+       Android.count_with_destroyed.should == 2
+    end
+
+    it "should not hit update/save related callbacks" do
+      lambda{
+        Android.first.update_attribute(:name, 'Robocop')
+      }.should raise_error
+
+      lambda{
+        Android.first.destroy
+      }.should_not raise_error
+    end
+
+    it "should soft-delete matching items on Model.destroy_all" do
+      lambda{
+        Android.destroy_all("owner_id = #{@luke.id}")
+      }.should change(Android, :count).from(2).to(0)
+      Android.count_with_destroyed.should == 2
+    end
+
+    describe 'related models' do
+      it "should no longer show up in the relationship to the owner" do
+        @luke.androids.size.should == 2
+        @r2d2.destroy
+        @luke.androids.size.should == 1
+      end
 
-  it "should handle before_destroy and after_destroy callbacks properly" do
-    edward = UndestroyablePirate.create(:name => 'Edward')
-    lambda{
-      edward.destroy
-    }.should_not change(UndestroyablePirate, :count)
+      it "should soft-delete on dependent destroys" do
+        lambda{
+          @luke.destroy
+        }.should change(Android, :count).from(2).to(0)
+        Android.count_with_destroyed.should == 2
+      end
 
-    raul = RandomPirate.create(:name => 'Raul')
-    lambda{
-      begin
+    end
+  end
+
+  describe 'finding destroyed models' do
+    it "should be able to find destroyed items via #find_with_destroyed" do
+      @r2d2.destroy
+      Android.find(:first, :conditions => {:name => 'R2D2'}).should be_blank
+      Android.first_with_destroyed(:conditions => {:name => 'R2D2'}).should_not be_blank
+    end
+
+    it "should be able to find only destroyed items via #find_destroyed_only" do
+      @r2d2.destroy
+      Android.all_destroyed_only.size.should == 1
+      Android.first_destroyed_only.should == @r2d2
+    end
+  end
+
+  describe 'calculations' do
+    it "should have a proper count inclusively and exclusively of destroyed items" do
+      @r2d2.destroy
+      @c3p0.destroy
+      Android.count.should == 0
+      Android.count_with_destroyed.should == 2
+    end
+
+    it "should respond to various calculations" do
+      @r2d2.destroy
+      Android.sum('id').should == @c3p0.id
+      Android.sum_with_destroyed('id').should == @r2d2.id + @c3p0.id
+      Android.average_with_destroyed('id').should == (@r2d2.id + @c3p0.id) / 2.0
+    end
+  end
+
+  describe 'deletion' do
+    it "should actually remove records on #delete_all" do
+      lambda{
+        Android.delete_all
+      }.should change(Android, :count_with_destroyed).from(2).to(0)
+    end
+
+    it "should actually remove records on #delete" do
+      lambda{
+        Android.first.delete
+      }.should change(Android, :count_with_destroyed).from(2).to(1)
+    end
+  end
+
+  describe 'restore' do
+    it "should allow restoring soft-deleted items" do
+      @r2d2.destroy
+      lambda{
+        @r2d2.restore
+      }.should change(Android, :count).from(1).to(2)
+    end
+
+    it "should not hit update/save related callbacks" do
+      @r2d2.destroy
+
+      lambda{
+        @r2d2.update_attribute(:name, 'Robocop')
+      }.should raise_error
+
+      lambda{
+        @r2d2.restore
+      }.should_not raise_error
+    end
+
+    it "should restore dependent models when being restored by default" do
+      @r2d2.destroy
+      lambda{
+        @r2d2.restore
+      }.should change(Component, :count).from(0).to(1)
+    end
+
+    it "should provide the option to not restore dependent models" do
+      @r2d2.destroy
+      lambda{
+        @r2d2.restore(:include_destroyed_dependents => false)
+      }.should_not change(Component, :count)
+    end
+  end
+
+  describe 'validations' do
+    it "should not ignore destroyed items in validation checks unless scoped" do
+      # Androids are not validates_uniqueness_of scoped
+      @r2d2.destroy
+      lambda{
+        Android.create!(:name => 'R2D2')
+      }.should raise_error(ActiveRecord::RecordInvalid)
+
+      lambda{
+        # creating shouldn't raise an error
+        another_r2d2 = AndroidWithScopedUniqueness.create!(:name => 'R2D2')
+        # neither should destroying the second incarnation since the
+        # validates_uniqueness_of is only applied on create
+        another_r2d2.destroy
+      }.should_not raise_error
+    end
+  end
+
+  describe 'alternate fields and field values' do
+    it "should properly function for boolean values" do
+      # ninjas are invisible by default.  not being ninjas, we can only
+      # find those that are visible
+      ninja = Ninja.create(:name => 'Esteban', :visible => true)
+      ninja.vanish # aliased to destroy
+      Ninja.first.should be_blank
+      Ninja.find_with_destroyed(:first).should == ninja
+
+      # we're only interested in pirates who are alive by default
+      pirate = Pirate.create(:name => 'Reginald')
+      pirate.destroy
+      Pirate.first.should be_blank
+      Pirate.find_with_destroyed(:first).should == pirate
+
+      # we're only interested in pirates who are dead by default.
+      # zombie pirates ftw!
+      DeadPirate.first.id.should == pirate.id
+      lambda{
+        DeadPirate.first.destroy
+      }.should change(Pirate, :count).from(0).to(1)
+    end
+  end
+
+  describe 'after_destroy and before_destroy callbacks' do
+    it "should rollback if before_destroy fails" do
+      edward = UndestroyablePirate.create(:name => 'Edward')
+      lambda{
         edward.destroy
-      rescue => ex
-        ex.message.should == 'after_destroy works'
-      end
-    }.should_not change(RandomPirate, :count)
+      }.should_not change(UndestroyablePirate, :count)
+    end
+
+    it "should rollback if after_destroy raises an error" do
+      raul = RandomPirate.create(:name => 'Raul')
+      lambda{
+        begin
+          raul.destroy
+        rescue => ex
+          ex.message.should == 'after_destroy works'
+        end
+      }.should_not change(RandomPirate, :count)
+    end
+
+    it "should handle callbacks normally assuming no failures are encountered" do
+      component = Component.first
+      lambda{
+        component.destroy
+      }.should change(component, :name).to(Component::NEW_NAME)
+    end
+
   end
 end

data/spec/models.rb

@@ -0,0 +1,67 @@
+class Person < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name
+  has_many :androids, :foreign_key => :owner_id, :dependent => :destroy
+end
+
+class Android < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name
+  has_many :components, :dependent => :destroy
+
+  is_paranoid
+
+  # this code is to ensure that our destroy and restore methods
+  # work without triggering before/after_update callbacks
+  before_update :raise_hell
+  def raise_hell
+    raise "hell"
+  end
+end
+
+class Component < ActiveRecord::Base #:nodoc:
+  is_paranoid
+  NEW_NAME = 'Something Else!'
+  
+  after_destroy :change_name
+  def change_name
+    self.update_attribute(:name, NEW_NAME)
+  end
+end
+
+class AndroidWithScopedUniqueness < ActiveRecord::Base #:nodoc:
+  set_table_name :androids
+  validates_uniqueness_of :name, :scope => :deleted_at
+  is_paranoid
+end
+
+class Ninja < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name, :scope => :visible
+  is_paranoid :field => [:visible, false, true]
+  
+  alias_method :vanish, :destroy
+end
+
+class Pirate < ActiveRecord::Base #:nodoc:
+  is_paranoid :field => [:alive, false, true]
+end
+
+class DeadPirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+  is_paranoid :field => [:alive, true, false]
+end
+
+class RandomPirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+
+  def after_destroy
+    raise 'after_destroy works'
+  end
+end
+
+class UndestroyablePirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+  is_paranoid :field => [:alive, false, true]
+
+  def before_destroy
+    false
+  end
+end

data/spec/schema.rb

@@ -23,7 +23,7 @@ ActiveRecord::Schema.define(:version => 20090317164830) do
 
   create_table "ninjas", :force => true do |t|
     t.string   "name"
-    t.boolean  "visible", :default => true
+    t.boolean  "visible", :default => false
   end
 
   create_table "pirates", :force => true do |t|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jchupp-is_paranoid
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors: 
 - Jeffrey Chupp
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-27 00:00:00 -07:00
+date: 2009-05-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - lib/is_paranoid.rb
 - spec/database.yml
 - spec/is_paranoid_spec.rb
+- spec/models.rb
 - spec/schema.rb
 - spec/spec.opts
 - spec/spec_helper.rb