acts_as_paranoid 0.4.2 → 0.4.3.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4045fd67f66b6cbbaae31fce07b7e6f5cadafd77
+  data.tar.gz: e97fdbb51832ea05c1704627a4ce43cce1d2a824
+SHA512:
+  metadata.gz: 01ff43ed7501da46e4c2dcd0f595ac689f26a578a8e11fdaa250f393befb9ac51ec07117ff9b7970ef67ef050c9212d504702be63bb7b9558c320fe3fcb942ca
+  data.tar.gz: 6075e2f197eb0c8545c3eb3e772079976f4485b34c1b3e1f65ae496da85dde0c5b275c0b2c3812918e59e2a58b0cfad3d0759675164852165a81b113eb9d8d1c

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Gonçalo Silva
+Copyright (c) 2014 Zachary Scott, Gonçalo Silva, Rick Olson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.markdown → README.md}

@@ -1,15 +1,11 @@
 # ActsAsParanoid
 
+[![Build Status](https://travis-ci.org/zzak/acts_as_paranoid.png?branch=master)](https://travis-ci.org/zzak/acts_as_paranoid)
+
 A simple plugin which hides records instead of deleting them, being able to recover them.
 
 **This branch targets Rails 3.2.** If you're working with another version, switch to the corresponding branch.
 
-## Credits
-
-This plugin was inspired by [acts_as_paranoid](http://github.com/technoweenie/acts_as_paranoid) and [acts_as_active](http://github.com/fernandoluizao/acts_as_active).
-
-While porting it to Rails 3, I decided to apply the ideas behind those plugins to an unified solution while removing a **lot** of the complexity found in them. I eventually ended up writing a new plugin from scratch.
-
 ## Usage
 
 You can enable ActsAsParanoid like this:
@@ -222,20 +218,21 @@ This gem supports the most recent versions of Rails and Ruby.
 
 For Rails 3.2 check the README at the [rails3.2](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.2) branch and add this to your Gemfile:
 
-	gem "acts_as_paranoid", "~>0.4.0"
+    gem "acts_as_paranoid", "~> 0.4.0"
 
 For Rails 3.1 check the README at the [rails3.1](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.1) branch and add this to your Gemfile:
 
-	gem "rails3_acts_as_paranoid", "~>0.1.4"
+    gem "rails3_acts_as_paranoid", "~>0.1.4"
 
 For Rails 3.0 check the README at the [rails3.0](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.0) branch and add this to your Gemfile:
 
-	gem "rails3_acts_as_paranoid", "~>0.0.9"
+    gem "rails3_acts_as_paranoid", "~>0.0.9"
 
 
 ## Ruby
 
-This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode). It *might* work fine in 1.8, but it's not officially supported.
+This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode).
+
 
 # Acknowledgements
 
@@ -247,4 +244,11 @@ This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode). It *might
 * To [Craig Walker](https://github.com/softcraft-development) for Rails 3.1 support and fixing various pending issues
 * To [Charles G.](https://github.com/chuckg) for Rails 3.2 support and for making a desperately needed global code refactoring
 
-Copyright © 2010 Gonçalo Silva, released under the MIT license
+## Credits
+
+This plugin was inspired by [acts_as_paranoid](http://github.com/technoweenie/acts_as_paranoid) and [acts_as_active](http://github.com/fernandoluizao/acts_as_active).
+
+While porting it to Rails 3, I decided to apply the ideas behind those plugins to an unified solution while removing a **lot** of the complexity found in them. I eventually ended up writing a new plugin from scratch.
+
+
+Copyright © 2014 Zachary Scott, Gonçalo Silva, Rick Olson, released under the MIT license

data/lib/acts_as_paranoid.rb

@@ -1,27 +1,23 @@
-require 'active_record/base'
-require 'active_record/relation'
-require 'active_record/callbacks'
 require 'acts_as_paranoid/core'
 require 'acts_as_paranoid/associations'
 require 'acts_as_paranoid/validations'
 require 'acts_as_paranoid/relation'
 
-
 module ActsAsParanoid
-  
+
   def paranoid?
     self.included_modules.include?(ActsAsParanoid::Core)
   end
-  
+
   def validates_as_paranoid
     include ActsAsParanoid::Validations
   end
-  
+
   def acts_as_paranoid(options = {})
     raise ArgumentError, "Hash expected, got #{options.class.name}" if not options.is_a?(Hash) and not options.empty?
-    
+
     class_attribute :paranoid_configuration, :paranoid_column_reference
-    
+
     self.paranoid_configuration = { :column => "deleted_at", :column_type => "time", :recover_dependent_associations => true, :dependent_recovery_window => 2.minutes }
     self.paranoid_configuration.merge!({ :deleted_value => "deleted" }) if options[:column_type] == "string"
     self.paranoid_configuration.merge!(options) # user options
@@ -29,17 +25,14 @@ module ActsAsParanoid
     raise ArgumentError, "'time', 'boolean' or 'string' expected for :column_type option, got #{paranoid_configuration[:column_type]}" unless ['time', 'boolean', 'string'].include? paranoid_configuration[:column_type]
 
     self.paranoid_column_reference = "#{self.table_name}.#{paranoid_configuration[:column]}"
-    
+
     return if paranoid?
-    
+
     include ActsAsParanoid::Core
-    
+
     # Magic!
     default_scope { where(paranoid_default_scope_sql) }
 
-    # The paranoid column should not be mass-assignable
-    attr_protected paranoid_configuration[:column]
-
     if paranoid_configuration[:column_type] == 'time'
       scope :deleted_inside_time_window, lambda {|time, window|
         deleted_after_time((time - window)).deleted_before_time((time + window))

data/lib/acts_as_paranoid/core.rb

@@ -134,17 +134,17 @@ module ActsAsParanoid
 
     def recover_dependent_associations(window, options)
       self.class.dependent_associations.each do |reflection|
-        next unless reflection.klass.paranoid?
+        next unless (klass = get_reflection_class(reflection)).paranoid?
 
-        scope = reflection.klass.only_deleted
+        scope = klass.only_deleted
 
         # Merge in the association's scope
         scope = scope.merge(association(reflection.name).association_scope)
 
         # We can only recover by window if both parent and dependant have a
         # paranoid column type of :time.
-        if self.class.paranoid_column_type == :time && reflection.klass.paranoid_column_type == :time
-          scope = scope.merge(reflection.klass.deleted_inside_time_window(paranoid_value, window))
+        if self.class.paranoid_column_type == :time && klass.paranoid_column_type == :time
+          scope = scope.merge(klass.deleted_inside_time_window(paranoid_value, window))
         end
 
         scope.each do |object|
@@ -155,9 +155,9 @@ module ActsAsParanoid
 
     def destroy_dependent_associations!
       self.class.dependent_associations.each do |reflection|
-        next unless reflection.klass.paranoid?
+        next unless (klass = get_reflection_class(reflection)).paranoid?
 
-        scope = reflection.klass.only_deleted
+        scope = klass.only_deleted
 
         # Merge in the association's scope
         scope = scope.merge(association(reflection.name).association_scope)
@@ -177,6 +177,14 @@ module ActsAsParanoid
 
     private
 
+    def get_reflection_class(reflection)
+      if reflection.macro == :belongs_to && reflection.options.include?(:polymorphic)
+        self.send(reflection.foreign_type).constantize
+      else
+        reflection.klass
+      end
+    end
+
     def paranoid_value=(value)
       self.send("#{self.class.paranoid_column}=", value)
     end

data/lib/acts_as_paranoid/relation.rb

@@ -5,7 +5,7 @@ module ActsAsParanoid
         def paranoid?
           klass.try(:paranoid?) ? true : false
         end
-        
+
         def paranoid_deletion_attributes
           { klass.paranoid_column => klass.delete_now_value }
         end
@@ -18,7 +18,7 @@ module ActsAsParanoid
             orig_delete_all
           end
         end
-        
+
         def delete_all(conditions = nil)
           if paranoid?
             update_all(paranoid_deletion_attributes, conditions)

data/lib/acts_as_paranoid/version.rb

@@ -0,0 +1,3 @@
+module ActsAsParanoid
+  VERSION = "0.4.3.pre"
+end

data/test/test_associations.rb

@@ -0,0 +1,222 @@
+require 'test_helper'
+
+class AssociationsTest < ParanoidBaseTest
+  def test_removal_with_associations
+    # This test shows that the current implementation doesn't handle
+    # assciation deletion correctly (when hard deleting via parent-object)
+    paranoid_company_1 = ParanoidDestroyCompany.create! :name => "ParanoidDestroyCompany #1"
+    paranoid_company_2 = ParanoidDeleteCompany.create! :name => "ParanoidDestroyCompany #1"
+    paranoid_company_1.paranoid_products.create! :name => "ParanoidProduct #1"
+    paranoid_company_2.paranoid_products.create! :name => "ParanoidProduct #2"
+
+    assert_equal 1, ParanoidDestroyCompany.count
+    assert_equal 1, ParanoidDeleteCompany.count
+    assert_equal 2, ParanoidProduct.count
+
+    ParanoidDestroyCompany.first.destroy
+    assert_equal 0, ParanoidDestroyCompany.count
+    assert_equal 1, ParanoidProduct.count
+    assert_equal 1, ParanoidDestroyCompany.with_deleted.count
+    assert_equal 2, ParanoidProduct.with_deleted.count
+
+    ParanoidDestroyCompany.with_deleted.first.destroy!
+    assert_equal 0, ParanoidDestroyCompany.count
+    assert_equal 1, ParanoidProduct.count
+    assert_equal 0, ParanoidDestroyCompany.with_deleted.count
+    assert_equal 1, ParanoidProduct.with_deleted.count
+
+    ParanoidDeleteCompany.with_deleted.first.destroy!
+    assert_equal 0, ParanoidDeleteCompany.count
+    assert_equal 0, ParanoidProduct.count
+    assert_equal 0, ParanoidDeleteCompany.with_deleted.count
+    assert_equal 0, ParanoidProduct.with_deleted.count
+  end
+
+  def test_belongs_to_with_deleted
+    paranoid_time = ParanoidTime.first
+    paranoid_has_many_dependant = paranoid_time.paranoid_has_many_dependants.create(:name => 'dependant!')
+
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_deleted
+
+    paranoid_time.destroy
+
+    assert_nil paranoid_has_many_dependant.paranoid_time(true)
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_deleted(true)
+  end
+
+  def test_belongs_to_polymorphic_with_deleted
+    paranoid_time = ParanoidTime.first
+    paranoid_has_many_dependant = ParanoidHasManyDependant.create!(:name => 'dependant!', :paranoid_time_polymorphic_with_deleted => paranoid_time)
+
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted
+
+    paranoid_time.destroy
+
+    assert_nil paranoid_has_many_dependant.paranoid_time(true)
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted(true)
+  end
+
+  def test_belongs_to_nil_polymorphic_with_deleted
+    paranoid_time = ParanoidTime.first
+    paranoid_has_many_dependant = ParanoidHasManyDependant.create!(:name => 'dependant!', :paranoid_time_polymorphic_with_deleted => nil)
+
+    assert_nil paranoid_has_many_dependant.paranoid_time
+    assert_nil paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted
+
+    paranoid_time.destroy
+
+    assert_nil paranoid_has_many_dependant.paranoid_time(true)
+    assert_nil paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted(true)
+  end
+
+  def test_belongs_to_options
+    paranoid_time = ParanoidHasManyDependant.reflections[:paranoid_time]
+    assert_equal :belongs_to, paranoid_time.macro
+    assert_nil paranoid_time.options[:with_deleted]
+  end
+
+  def test_belongs_to_with_deleted_options
+    paranoid_time_with_deleted = ParanoidHasManyDependant.reflections[:paranoid_time_with_deleted]
+    assert_equal :belongs_to, paranoid_time_with_deleted.macro
+    assert paranoid_time_with_deleted.options[:with_deleted]
+  end
+
+  def test_belongs_to_polymorphic_with_deleted_options
+    paranoid_time_polymorphic_with_deleted = ParanoidHasManyDependant.reflections[:paranoid_time_polymorphic_with_deleted]
+    assert_equal :belongs_to, paranoid_time_polymorphic_with_deleted.macro
+    assert paranoid_time_polymorphic_with_deleted.options[:with_deleted]
+  end
+
+  def test_only_find_associated_records_when_finding_with_paranoid_deleted
+    parent = ParanoidBelongsDependant.create
+    child = ParanoidHasManyDependant.create
+    parent.paranoid_has_many_dependants << child
+
+    unrelated_parent = ParanoidBelongsDependant.create
+    unrelated_child = ParanoidHasManyDependant.create
+    unrelated_parent.paranoid_has_many_dependants << unrelated_child
+
+    child.destroy
+    assert_paranoid_deletion(child)
+
+    assert_equal [child], parent.paranoid_has_many_dependants.with_deleted.to_a
+  end
+
+  def test_cannot_find_a_paranoid_deleted_many_many_association
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    left.paranoid_many_many_parent_rights.delete(right)
+
+    left.reload
+
+    assert_equal [], left.paranoid_many_many_children, "Linking objects not deleted"
+    assert_equal [], left.paranoid_many_many_parent_rights, "Associated objects not unlinked"
+    assert_equal right, ParanoidManyManyParentRight.find(right.id), "Associated object deleted"
+  end
+
+  def test_cannot_find_a_paranoid_destroyed_many_many_association
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    left.paranoid_many_many_parent_rights.destroy(right)
+
+    left.reload
+
+    assert_equal [], left.paranoid_many_many_children, "Linking objects not deleted"
+    assert_equal [], left.paranoid_many_many_parent_rights, "Associated objects not unlinked"
+    assert_equal right, ParanoidManyManyParentRight.find(right.id), "Associated object deleted"
+  end
+
+  def test_cannot_find_a_has_many_through_object_when_its_linking_object_is_paranoid_destroyed
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    child = left.paranoid_many_many_children.first
+
+    child.destroy
+
+    left.reload
+
+    assert_equal [], left.paranoid_many_many_parent_rights, "Associated objects not deleted"
+  end
+
+  def test_cannot_find_a_paranoid_deleted_model
+    model = ParanoidBelongsDependant.create
+    model.destroy
+
+    assert_raises ActiveRecord::RecordNotFound do
+      ParanoidBelongsDependant.find(model.id)
+    end
+  end
+
+  def test_bidirectional_has_many_through_association_clear_is_paranoid
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    child = left.paranoid_many_many_children.first
+    assert_equal left, child.paranoid_many_many_parent_left, "Child's left parent is incorrect"
+    assert_equal right, child.paranoid_many_many_parent_right, "Child's right parent is incorrect"
+
+    left.paranoid_many_many_parent_rights.clear
+
+    assert_paranoid_deletion(child)
+  end
+
+  def test_bidirectional_has_many_through_association_destroy_is_paranoid
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    child = left.paranoid_many_many_children.first
+    assert_equal left, child.paranoid_many_many_parent_left, "Child's left parent is incorrect"
+    assert_equal right, child.paranoid_many_many_parent_right, "Child's right parent is incorrect"
+
+    left.paranoid_many_many_parent_rights.destroy(right)
+
+    assert_paranoid_deletion(child)
+  end
+
+  def test_bidirectional_has_many_through_association_delete_is_paranoid
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    child = left.paranoid_many_many_children.first
+    assert_equal left, child.paranoid_many_many_parent_left, "Child's left parent is incorrect"
+    assert_equal right, child.paranoid_many_many_parent_right, "Child's right parent is incorrect"
+
+    left.paranoid_many_many_parent_rights.delete(right)
+
+    assert_paranoid_deletion(child)
+  end
+
+  def test_belongs_to_on_normal_model_is_paranoid
+    not_paranoid = HasOneNotParanoid.create
+    not_paranoid.paranoid_time = ParanoidTime.create
+
+    assert not_paranoid.save
+    assert_not_nil not_paranoid.paranoid_time
+  end
+
+  def test_double_belongs_to_with_deleted
+    not_paranoid = DoubleHasOneNotParanoid.create
+    not_paranoid.paranoid_time = ParanoidTime.create
+
+    assert not_paranoid.save
+    assert_not_nil not_paranoid.paranoid_time
+  end
+
+  def test_mass_assignment_of_paranoid_column_enabled
+    now = Time.now
+    record = ParanoidTime.create! :name => 'Foo', :deleted_at => now
+    assert_equal 'Foo', record.name
+    assert_equal now, record.deleted_at
+  end
+end

data/test/test_core.rb

@@ -0,0 +1,387 @@
+require 'test_helper'
+
+class ParanoidTest < ParanoidBaseTest
+  def test_paranoid?
+    assert !NotParanoid.paranoid?
+    assert_raise(NoMethodError) { NotParanoid.delete_all! }
+    assert_raise(NoMethodError) { NotParanoid.first.destroy! }
+    assert_raise(NoMethodError) { NotParanoid.with_deleted }
+    assert_raise(NoMethodError) { NotParanoid.only_deleted }
+
+    assert ParanoidTime.paranoid?
+  end
+
+  def test_scope_inclusion_with_time_column_type
+    assert ParanoidTime.respond_to?(:deleted_inside_time_window)
+    assert ParanoidTime.respond_to?(:deleted_before_time)
+    assert ParanoidTime.respond_to?(:deleted_after_time)
+
+    assert !ParanoidBoolean.respond_to?(:deleted_inside_time_window)
+    assert !ParanoidBoolean.respond_to?(:deleted_before_time)
+    assert !ParanoidBoolean.respond_to?(:deleted_after_time)
+  end
+
+  def test_fake_removal
+    assert_equal 3, ParanoidTime.count
+    assert_equal 3, ParanoidBoolean.count
+    assert_equal 1, ParanoidString.count
+
+    ParanoidTime.first.destroy
+    ParanoidBoolean.delete_all("name = 'paranoid' OR name = 'really paranoid'")
+    ParanoidString.first.destroy
+    assert_equal 2, ParanoidTime.count
+    assert_equal 1, ParanoidBoolean.count
+    assert_equal 0, ParanoidString.count
+    assert_equal 1, ParanoidTime.only_deleted.count
+    assert_equal 2, ParanoidBoolean.only_deleted.count
+    assert_equal 1, ParanoidString.only_deleted.count
+    assert_equal 3, ParanoidTime.with_deleted.count
+    assert_equal 3, ParanoidBoolean.with_deleted.count
+    assert_equal 1, ParanoidString.with_deleted.count
+  end
+
+  def test_real_removal
+    ParanoidTime.first.destroy!
+    ParanoidBoolean.delete_all!("name = 'extremely paranoid' OR name = 'really paranoid'")
+    ParanoidString.first.destroy!
+    assert_equal 2, ParanoidTime.count
+    assert_equal 1, ParanoidBoolean.count
+    assert_equal 0, ParanoidString.count
+    assert_equal 2, ParanoidTime.with_deleted.count
+    assert_equal 1, ParanoidBoolean.with_deleted.count
+    assert_equal 0, ParanoidString.with_deleted.count
+    assert_equal 0, ParanoidTime.only_deleted.count
+    assert_equal 0, ParanoidBoolean.only_deleted.count
+    assert_equal 0, ParanoidString.only_deleted.count
+
+    ParanoidTime.first.destroy
+    ParanoidTime.only_deleted.first.destroy
+    assert_equal 0, ParanoidTime.only_deleted.count
+
+    ParanoidTime.delete_all!
+    assert_empty ParanoidTime.all
+    assert_empty ParanoidTime.with_deleted.all
+  end
+
+  def test_non_persisted_destroy
+    pt = ParanoidTime.new
+    assert_nil pt.paranoid_value
+    pt.destroy
+    assert_not_nil pt.paranoid_value
+  end
+
+  def test_non_persisted_destroy!
+    pt = ParanoidTime.new
+    assert_nil pt.paranoid_value
+    pt.destroy!
+    assert_not_nil pt.paranoid_value
+  end
+
+  def test_recovery
+    assert_equal 3, ParanoidBoolean.count
+    ParanoidBoolean.first.destroy
+    assert_equal 2, ParanoidBoolean.count
+    ParanoidBoolean.only_deleted.first.recover
+    assert_equal 3, ParanoidBoolean.count
+
+    assert_equal 1, ParanoidString.count
+    ParanoidString.first.destroy
+    assert_equal 0, ParanoidString.count
+    ParanoidString.with_deleted.first.recover
+    assert_equal 1, ParanoidString.count
+  end
+
+  def setup_recursive_tests
+    @paranoid_time_object = ParanoidTime.first
+
+    # Create one extra ParanoidHasManyDependant record so that we can validate
+    # the correct dependants are recovered.
+    ParanoidTime.where('id <> ?', @paranoid_time_object.id).first.paranoid_has_many_dependants.create(:name => "should not be recovered").destroy
+
+    @paranoid_boolean_count = ParanoidBoolean.count
+
+    assert_equal 0, ParanoidHasManyDependant.count
+    assert_equal 0, ParanoidBelongsDependant.count
+    assert_equal 1, NotParanoid.count
+
+    (1..3).each do |i|
+      has_many_object = @paranoid_time_object.paranoid_has_many_dependants.create(:name => "has_many_#{i}")
+      has_many_object.create_paranoid_belongs_dependant(:name => "belongs_to_#{i}")
+      has_many_object.save
+
+      paranoid_boolean = @paranoid_time_object.paranoid_booleans.create(:name => "boolean_#{i}")
+      paranoid_boolean.create_paranoid_has_one_dependant(:name => "has_one_#{i}")
+      paranoid_boolean.save
+
+      @paranoid_time_object.not_paranoids.create(:name => "not_paranoid_a#{i}")
+
+    end
+
+    @paranoid_time_object.create_not_paranoid(:name => "not_paranoid_belongs_to")
+    @paranoid_time_object.create_has_one_not_paranoid(:name => "has_one_not_paranoid")
+
+    assert_equal 3, ParanoidTime.count
+    assert_equal 3, ParanoidHasManyDependant.count
+    assert_equal 3, ParanoidBelongsDependant.count
+    assert_equal @paranoid_boolean_count + 3, ParanoidBoolean.count
+    assert_equal 3, ParanoidHasOneDependant.count
+    assert_equal 5, NotParanoid.count
+    assert_equal 1, HasOneNotParanoid.count
+  end
+
+  def test_recursive_fake_removal
+    setup_recursive_tests
+
+    @paranoid_time_object.destroy
+
+    assert_equal 2, ParanoidTime.count
+    assert_equal 0, ParanoidHasManyDependant.count
+    assert_equal 0, ParanoidBelongsDependant.count
+    assert_equal @paranoid_boolean_count, ParanoidBoolean.count
+    assert_equal 0, ParanoidHasOneDependant.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+  end
+
+  def test_recursive_real_removal
+    setup_recursive_tests
+
+    @paranoid_time_object.destroy!
+
+    assert_equal 0, ParanoidTime.only_deleted.count
+    assert_equal 1, ParanoidHasManyDependant.only_deleted.count
+    assert_equal 0, ParanoidBelongsDependant.only_deleted.count
+    assert_equal 0, ParanoidBoolean.only_deleted.count
+    assert_equal 0, ParanoidHasOneDependant.only_deleted.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+  end
+
+  def test_recursive_recovery
+    setup_recursive_tests
+
+    @paranoid_time_object.destroy
+    @paranoid_time_object.reload
+
+    @paranoid_time_object.recover(:recursive => true)
+
+    assert_equal 3, ParanoidTime.count
+    assert_equal 3, ParanoidHasManyDependant.count
+    assert_equal 3, ParanoidBelongsDependant.count
+    assert_equal @paranoid_boolean_count + 3, ParanoidBoolean.count
+    assert_equal 3, ParanoidHasOneDependant.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+  end
+
+  def test_recursive_recovery_dependant_window
+    setup_recursive_tests
+
+    @paranoid_time_object.destroy
+    @paranoid_time_object.reload
+
+    # Stop the following from recovering:
+    #   - ParanoidHasManyDependant and its ParanoidBelongsDependant
+    #   - A single ParanoidBelongsDependant, but not its parent
+    dependants = @paranoid_time_object.paranoid_has_many_dependants.with_deleted
+    dependants.first.update_attribute(:deleted_at, 2.days.ago)
+    ParanoidBelongsDependant.with_deleted.where(:id => dependants.last.paranoid_belongs_dependant_id).first.update_attribute(:deleted_at, 1.hour.ago)
+
+    @paranoid_time_object.recover(:recursive => true)
+
+    assert_equal 3, ParanoidTime.count
+    assert_equal 2, ParanoidHasManyDependant.count
+    assert_equal 1, ParanoidBelongsDependant.count
+    assert_equal @paranoid_boolean_count + 3, ParanoidBoolean.count
+    assert_equal 3, ParanoidHasOneDependant.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+  end
+
+  def test_recursive_recovery_for_belongs_to_polymorphic
+    child_1 = ParanoidAndroid.create
+    section_1 = ParanoidSection.create(:paranoid_thing => child_1)
+
+    child_2 = ParanoidHuman.create(:gender => 'male')
+    section_2 = ParanoidSection.create(:paranoid_thing => child_2)
+
+    assert_equal section_1.paranoid_thing, child_1
+    assert_equal section_1.paranoid_thing.class, ParanoidAndroid
+    assert_equal section_2.paranoid_thing, child_2
+    assert_equal section_2.paranoid_thing.class, ParanoidHuman
+
+    parent = ParanoidTime.create(:name => "paranoid_parent")
+    parent.paranoid_sections << section_1
+    parent.paranoid_sections << section_2
+
+    assert_equal 4, ParanoidTime.count
+    assert_equal 2, ParanoidSection.count
+    assert_equal 1, ParanoidAndroid.count
+    assert_equal 1, ParanoidHuman.count
+
+    parent.destroy
+
+    assert_equal 3, ParanoidTime.count
+    assert_equal 0, ParanoidSection.count
+    assert_equal 0, ParanoidAndroid.count
+    assert_equal 0, ParanoidHuman.count
+
+    parent.reload
+    parent.recover
+
+    assert_equal 4, ParanoidTime.count
+    assert_equal 2, ParanoidSection.count
+    assert_equal 1, ParanoidAndroid.count
+    assert_equal 1, ParanoidHuman.count
+  end
+
+  def test_non_recursive_recovery
+    setup_recursive_tests
+
+    @paranoid_time_object.destroy
+    @paranoid_time_object.reload
+
+    @paranoid_time_object.recover(:recursive => false)
+
+    assert_equal 3, ParanoidTime.count
+    assert_equal 0, ParanoidHasManyDependant.count
+    assert_equal 0, ParanoidBelongsDependant.count
+    assert_equal @paranoid_boolean_count, ParanoidBoolean.count
+    assert_equal 0, ParanoidHasOneDependant.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+  end
+
+  def test_deleted?
+    ParanoidTime.first.destroy
+    assert ParanoidTime.with_deleted.first.deleted?
+
+    ParanoidString.first.destroy
+    assert ParanoidString.with_deleted.first.deleted?
+  end
+
+  def test_paranoid_destroy_callbacks
+    @paranoid_with_callback = ParanoidWithCallback.first
+    ParanoidWithCallback.transaction do
+      @paranoid_with_callback.destroy
+    end
+
+    assert @paranoid_with_callback.called_before_destroy
+    assert @paranoid_with_callback.called_after_destroy
+    assert @paranoid_with_callback.called_after_commit_on_destroy
+  end
+
+  def test_hard_destroy_callbacks
+    @paranoid_with_callback = ParanoidWithCallback.first
+
+    ParanoidWithCallback.transaction do
+      @paranoid_with_callback.destroy!
+    end
+
+    assert @paranoid_with_callback.called_before_destroy
+    assert @paranoid_with_callback.called_after_destroy
+    assert @paranoid_with_callback.called_after_commit_on_destroy
+  end
+
+  def test_recovery_callbacks
+    @paranoid_with_callback = ParanoidWithCallback.first
+
+    ParanoidWithCallback.transaction do
+      @paranoid_with_callback.destroy
+
+      assert_nil @paranoid_with_callback.called_before_recover
+      assert_nil @paranoid_with_callback.called_after_recover
+
+      @paranoid_with_callback.recover
+    end
+
+      assert @paranoid_with_callback.called_before_recover
+      assert @paranoid_with_callback.called_after_recover
+  end
+
+  def test_delete_by_multiple_id_is_paranoid
+    model_a = ParanoidBelongsDependant.create
+    model_b = ParanoidBelongsDependant.create
+    ParanoidBelongsDependant.delete([model_a.id, model_b.id])
+
+    assert_paranoid_deletion(model_a)
+    assert_paranoid_deletion(model_b)
+  end
+
+  def test_destroy_by_multiple_id_is_paranoid
+    model_a = ParanoidBelongsDependant.create
+    model_b = ParanoidBelongsDependant.create
+    ParanoidBelongsDependant.destroy([model_a.id, model_b.id])
+
+    assert_paranoid_deletion(model_a)
+    assert_paranoid_deletion(model_b)
+  end
+
+  def test_delete_by_single_id_is_paranoid
+    model = ParanoidBelongsDependant.create
+    ParanoidBelongsDependant.delete(model.id)
+
+    assert_paranoid_deletion(model)
+  end
+
+  def test_destroy_by_single_id_is_paranoid
+    model = ParanoidBelongsDependant.create
+    ParanoidBelongsDependant.destroy(model.id)
+
+    assert_paranoid_deletion(model)
+  end
+
+  def test_instance_delete_is_paranoid
+    model = ParanoidBelongsDependant.create
+    model.delete
+
+    assert_paranoid_deletion(model)
+  end
+
+  def test_instance_destroy_is_paranoid
+    model = ParanoidBelongsDependant.create
+    model.destroy
+
+    assert_paranoid_deletion(model)
+  end
+
+  # Test string type columns that don't have a nil value when not deleted (Y/N for example)
+  def test_string_type_with_no_nil_value_before_destroy
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    assert_equal 1, ParanoidString.where(:id => ps).count
+  end
+
+  def test_string_type_with_no_nil_value_after_destroy
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps.destroy
+    assert_equal 0, ParanoidString.where(:id => ps).count
+  end
+
+  def test_string_type_with_no_nil_value_before_destroy_with_deleted
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    assert_equal 1, ParanoidString.with_deleted.where(:id => ps).count
+  end
+
+  def test_string_type_with_no_nil_value_after_destroy_with_deleted
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps.destroy
+    assert_equal 1, ParanoidString.with_deleted.where(:id => ps).count
+  end
+
+  def test_string_type_with_no_nil_value_before_destroy_only_deleted
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    assert_equal 0, ParanoidString.only_deleted.where(:id => ps).count
+  end
+
+  def test_string_type_with_no_nil_value_after_destroy_only_deleted
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps.destroy
+    assert_equal 1, ParanoidString.only_deleted.where(:id => ps).count
+  end
+
+  def test_string_type_with_no_nil_value_after_destroyed_twice
+    ps = ParanoidString.create!(:deleted => 'not dead')
+    2.times { ps.destroy }
+    assert_equal 0, ParanoidString.with_deleted.where(:id => ps).count
+  end
+end