kakurenbo 0.1.3 → 0.2.0

data/spec/kakurenbo/soft_delete_cores/associations_spec.rb

@@ -1,270 +0,0 @@
-require 'spec_helper'
-
-describe Kakurenbo::SoftDeleteCore do
-  create_temp_table(:parent_models)                { |t| t.integer :child_id; t.datetime :deleted_at }
-  create_temp_table(:normal_child_models)          { |t| t.integer :parent_model_id }
-  create_temp_table(:paranoid_child_models)        { |t| t.integer :parent_model_id; t.datetime :deleted_at }
-  create_temp_table(:paranoid_single_child_models) { |t| t.integer :parent_model_id; t.datetime :deleted_at }
-
-  before :each do
-    class NormalChildModel  < ActiveRecord::Base; end
-    class ParanoidChildModel < ActiveRecord::Base; end
-    class ParanoidSingleChildModel < ActiveRecord::Base; end
-    class ParentModel < ActiveRecord::Base
-      has_many :normal_child_models,   :dependent => :destroy
-      has_many :paranoid_child_models, :dependent => :destroy
-
-      has_one     :paranoid_single_child_model, :dependent => :destroy
-      belongs_to  :child, :class_name => :ParanoidSingleChildModel, :dependent => :destroy
-    end
-  end
-
-  after :each do
-    Object.class_eval do
-      remove_const :NormalChildModel
-      remove_const :ParanoidChildModel
-      remove_const :ParanoidSingleChildModel
-      remove_const :ParentModel
-    end
-  end
-
-  describe 'NormalChildModel' do
-    before :each do
-      @parent = ParentModel.create!
-      @first  = @parent.normal_child_models.create!
-      @second = @parent.normal_child_models.create!
-
-      @hitori = NormalChildModel.create!
-    end
-
-    context 'when parent be destroyed' do
-      it 'destroy children who parent has.' do
-        expect{@parent.destroy}.to change(NormalChildModel, :count).by(-2)
-      end
-
-      it 'not destroy children who parent does not have.' do
-        @parent.destroy
-        expect(@hitori.reload.destroyed?).to be_false
-      end
-    end
-  end
-
-  describe 'ParanoidChildModel' do
-    before :each do
-      @parent = ParentModel.create!
-      @first  = @parent.paranoid_child_models.create!
-      @second = @parent.paranoid_child_models.create!
-      @third  = @parent.paranoid_child_models.create!
-
-      @hitori = ParanoidChildModel.create!
-    end
-
-    context 'when parent be destroyed' do
-      it 'destroy children who parent has.' do
-        expect{@parent.destroy}.to change(ParanoidChildModel, :count).by(-3)
-        expect(@first.reload.destroyed?).to be_true
-        expect(@second.reload.destroyed?).to be_true
-        expect(@third.reload.destroyed?).to be_true
-      end
-
-      it 'not destroy children who parent does not have.' do
-        @parent.destroy
-        expect(@hitori.reload.destroyed?).to be_false
-      end
-    end
-
-    context 'when parent be restored' do
-      before :each do
-        @parent.destroy
-        @hitori.destroy
-      end
-
-      it 'restore children who parent has.' do
-        expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(3)
-        expect(@first.reload.destroyed?).to be_false
-        expect(@second.reload.destroyed?).to be_false
-        expect(@third.reload.destroyed?).to be_false
-      end
-
-      it 'not restore children who parent does not have.' do
-        @parent.restore!
-        expect(@hitori.reload.destroyed?).to be_true
-      end
-    end
-
-    context 'when delete child before parent was deleted' do
-      before :each do
-        # First, delete child.
-        delete_at = 1.second.ago
-        Time.stub(:now).and_return(delete_at)
-        @first.destroy
-
-        # Next, delete parent.
-        Time.unstub(:now)
-        @parent.destroy
-      end
-
-      it 'not restore child who deleted before parent was deleted' do
-        expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(2)
-        expect(@first.reload.destroyed?).to be_true
-      end
-
-      it 'restore children who deleted after parent was deleted' do
-        expect{@parent.restore!}.to change(ParanoidChildModel, :count).by(2)
-        expect(@second.reload.destroyed?).to be_false
-        expect(@third.reload.destroyed?).to be_false
-      end
-    end
-  end
-
-  describe 'ParanoidSingleChildModel(has_one)' do
-    before :each do
-      @parent = ParentModel.create!
-      @first  = ParanoidSingleChildModel.create!(parent_model_id: @parent.id)
-
-      @hitori = ParanoidSingleChildModel.create!
-    end
-
-    context 'when parent be destroyed' do
-      it 'destroy child who parent has.' do
-        expect{@parent.destroy}.to change(ParanoidSingleChildModel, :count).by(-1)
-        expect(@first.reload.destroyed?).to be_true
-      end
-
-      it 'not destroy child who parent does not have.' do
-        @parent.destroy
-        expect(@hitori.reload.destroyed?).to be_false
-      end
-    end
-
-    context 'when parent be restored' do
-      before :each do
-        @parent.destroy
-        @hitori.destroy
-      end
-
-      it 'restore child who parent has.' do
-        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(1)
-        expect(@first.reload.destroyed?).to be_false
-      end
-
-      it 'not restore child who parent does not have.' do
-        @parent.restore
-        expect(@hitori.reload.destroyed?).to be_true
-      end
-    end
-
-    context 'when delete child before parent was deleted' do
-      before :each do
-        # First, delete child.
-        delete_at = 1.second.ago
-        Time.stub(:now).and_return(delete_at)
-        @first.destroy
-
-        # Next, delete parent.
-        Time.unstub(:now)
-        @parent.destroy
-      end
-
-      it 'not restore child who deleted before parent was deleted' do
-        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(0)
-        expect(@first.reload.destroyed?).to be_true
-      end
-    end
-  end
-
-  describe 'ParanoidSingleChildModel(belongs_to)' do
-    before :each do
-      @first  = ParanoidSingleChildModel.create!
-      @parent = ParentModel.create!(child_id: @first.id)
-
-      @hitori = ParanoidSingleChildModel.create!
-    end
-
-    context 'when parent be destroyed' do
-      it 'destroy child who parent has.' do
-        expect{@parent.destroy}.to change(ParanoidSingleChildModel, :count).by(-1)
-        expect(@first.reload.destroyed?).to be_true
-      end
-
-      it 'not destroy child who parent does not have.' do
-        @parent.destroy
-        expect(@hitori.reload.destroyed?).to be_false
-      end
-    end
-
-    context 'when parent be restored' do
-      before :each do
-        @parent.destroy
-        @hitori.destroy
-      end
-
-      it 'restore child who parent has.' do
-        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(1)
-        expect(@first.reload.destroyed?).to be_false
-      end
-
-      it 'not restore child who parent does not have.' do
-        @parent.restore
-        expect(@hitori.reload.destroyed?).to be_true
-      end
-    end
-
-    context 'when delete child before parent was deleted' do
-      before :each do
-        # First, delete child.
-        delete_at = 1.second.ago
-        Time.stub(:now).and_return(delete_at)
-        @first.destroy
-
-        # Next, delete parent.
-        Time.unstub(:now)
-        @parent.destroy
-      end
-
-      it 'not restore child who deleted before parent was deleted' do
-        expect{@parent.restore!}.to change(ParanoidSingleChildModel, :count).by(0)
-        expect(@first.reload.destroyed?).to be_true
-      end
-    end
-  end
-
-  describe 'ChildModels' do
-    before :each do
-      @parent = ParentModel.create!
-
-      @normal_first    = @parent.normal_child_models.create!
-      @normal_second   = @parent.normal_child_models.create!
-
-      @paranoid_first  = @parent.paranoid_child_models.create!
-      @paranoid_second = @parent.paranoid_child_models.create!
-
-      @single_first    = ParanoidSingleChildModel.create!(parent_model_id: @parent.id)
-
-      @normal_hitori   = NormalChildModel.create!
-      @paranoid_hitori = ParanoidChildModel.create!
-      @single_hitori   = ParanoidSingleChildModel.create!
-    end
-
-    context 'when parent be hard-destroyed' do
-      it 'hard-destroy normal children who parent has.' do
-        expect{@parent.destroy!}.to change(NormalChildModel, :count).by(-2)
-      end
-
-      it 'hard-destroy paranoid children who parent has.' do
-        expect{@parent.destroy!}.to change{ParanoidChildModel.with_deleted.count}.by(-2)
-      end
-
-      it 'hard-destroy paranoid single child who parent has.' do
-        expect{@parent.destroy!}.to change{ParanoidSingleChildModel.with_deleted.count}.by(-1)
-      end
-
-      it 'not destroy child who parent does not have.' do
-        @parent.destroy!
-        expect(@normal_hitori.reload.destroyed?).to   be_false
-        expect(@paranoid_hitori.reload.destroyed?).to be_false
-        expect(@single_hitori.reload.destroyed?).to   be_false
-      end
-    end
-  end
-end

data/spec/kakurenbo/soft_delete_cores/callbacks_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Kakurenbo::SoftDeleteCore::Callbacks do
-  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
-
-  before :each do
-    class ParanoidModel < ActiveRecord::Base; end
-  end
-
-  after :each do
-    Object.class_eval{ remove_const :ParanoidModel }
-  end
-
-  context 'when run callback of restore' do
-    before :each do
-      @callback_model = ParanoidModel.create!
-    end
-
-    after :each do
-      @callback_model.run_callbacks(:restore)
-    end
-
-    it 'call before_restore.' do
-      ParanoidModel.before_restore :before_restore_callback
-      @callback_model.should_receive(:before_restore_callback).once
-    end
-
-    it 'call around_restore.' do
-      ParanoidModel.around_restore :around_restore_callback
-      @callback_model.should_receive(:around_restore_callback).once
-    end
-
-    it 'call after_restore.' do
-      ParanoidModel.after_restore :after_restore_callback
-      @callback_model.should_receive(:after_restore_callback).once
-    end
-  end
-end

data/spec/kakurenbo/soft_delete_cores/core_spec.rb

@@ -1,229 +0,0 @@
-require 'spec_helper'
-
-describe Kakurenbo::SoftDeleteCore do
-  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
-
-  before :each do
-    class ParanoidModel < ActiveRecord::Base; end
-  end
-
-  after :each do
-    Object.class_eval{ remove_const :ParanoidModel }
-  end
-
-  describe 'Instance of paranoid model' do
-    before :each do
-      @model = ParanoidModel.create!
-    end
-
-    context 'when delete' do
-      it 'soft-delete model.' do
-        expect{
-          @model.delete
-        }.to change(ParanoidModel, :count).by(-1)
-      end
-
-      it 'not hard-delete model.' do
-        expect{
-          @model.delete
-        }.to change{
-          ParanoidModel.all.with_deleted.count
-        }.by(0)
-      end
-
-      it 'call callbacks nothing.' do
-        ParanoidModel.before_destroy :before_destroy_callback
-        ParanoidModel.after_destroy  :after_destroy_callback
-        ParanoidModel.after_commit   :after_commit_callback
-
-        @model.should_receive(:before_destroy_callback).exactly(0).times
-        @model.should_receive(:after_destroy_callback).exactly(0).times
-        @model.should_receive(:after_commit_callback).exactly(0).times
-
-        @model.delete
-      end
-
-      it 'not call callbacks other.' do
-        ParanoidModel.before_update :before_update_callback
-        ParanoidModel.before_save   :before_save_callback
-        ParanoidModel.validate      :validate_callback
-
-        @model.should_receive(:before_update_callback).exactly(0).times
-        @model.should_receive(:before_save_callback).exactly(0).times
-        @model.should_receive(:validate_callback).exactly(0).times
-
-        @model.delete
-      end
-    end
-
-    context 'when delete!' do
-      it 'hard-delete model.' do
-        expect{
-          @model.delete!
-        }.to change{
-          ParanoidModel.all.with_deleted.count
-        }.by(-1)
-      end
-    end
-
-    context 'when destroy(class method)' do
-      before :each do
-        @model2 = ParanoidModel.create!
-      end
-
-      it 'with id, destroy model.' do
-        expect{
-          ParanoidModel.destroy(@model.id)
-        }.to change(ParanoidModel, :count).by(-1)
-
-        expect(@model.reload.destroyed?).to be_true
-      end
-
-      it 'with ids, destroy models.' do
-        expect{
-          ParanoidModel.destroy([@model.id, @model2.id])
-        }.to change(ParanoidModel, :count).by(-2)
-
-        expect(@model.reload.destroyed?).to be_true
-        expect(@model2.reload.destroyed?).to be_true
-      end
-    end
-
-    context 'when destroy(instance method)' do
-      it 'soft-delete model.' do
-        expect{
-          @model.destroy
-        }.to change(ParanoidModel, :count).by(-1)
-      end
-
-      it 'not hard-delete model.' do
-        expect{
-          @model.destroy
-        }.to change{
-          ParanoidModel.all.with_deleted.count
-        }.by(0)
-      end
-
-      it 'call callbacks of destroy.' do
-        ParanoidModel.before_destroy :before_destroy_callback
-        ParanoidModel.after_destroy  :after_destroy_callback
-        ParanoidModel.after_commit   :after_commit_callback
-
-        @model.should_receive(:before_destroy_callback).once
-        @model.should_receive(:after_destroy_callback).once
-        @model.should_receive(:after_commit_callback).once.and_return(true)
-
-        @model.destroy
-      end
-
-      it 'not call callbacks without destroy.' do
-        ParanoidModel.before_update :before_update_callback
-        ParanoidModel.before_save   :before_save_callback
-        ParanoidModel.validate      :validate_callback
-
-        @model.should_receive(:before_update_callback).exactly(0).times
-        @model.should_receive(:before_save_callback).exactly(0).times
-        @model.should_receive(:validate_callback).exactly(0).times
-
-        @model.destroy
-      end
-    end
-
-    context 'when destroy!' do
-      it 'hard-delete model.' do
-        expect{
-          @model.destroy!
-        }.to change{
-          ParanoidModel.all.with_deleted.count
-        }.by(-1)
-      end
-    end
-
-    context 'when destroyed?' do
-      it 'false if model not destroyed.' do
-        expect(@model.destroyed?).to be_false
-      end
-
-      it 'false if model destroyed.' do
-        @model.destroy
-        expect(@model.destroyed?).to be_true
-      end
-
-      it 'alias deleted? to destroyed?' do
-        expect(@model.deleted?).to be_false
-      end
-    end
-
-    context 'when restore(class method)' do
-      before :each do
-        @model.destroy
-
-        @model2 = ParanoidModel.create!
-        @model2.destroy
-      end
-
-      it 'with id, restore model.' do
-        expect{
-          ParanoidModel.restore(@model.id)
-        }.to change(ParanoidModel, :count).by(1)
-
-        expect(@model.reload.destroyed?).to be_false
-      end
-
-      it 'with ids, restore models.' do
-        expect{
-          ParanoidModel.restore([@model.id, @model2.id])
-        }.to change(ParanoidModel, :count).by(2)
-
-        expect(@model.reload.destroyed?).to be_false
-        expect(@model2.reload.destroyed?).to be_false
-      end
-    end
-
-    context 'when restore(instance method)' do
-      before :each do
-        @model.destroy
-      end
-
-      it 'restore model' do
-        expect{
-          @model.restore!
-        }.to change(ParanoidModel, :count).by(1)
-
-        expect(@model.reload.destroyed?).to be_false
-      end
-
-      it 'call callbacks of restore.' do
-        ParanoidModel.before_restore :before_restore_callback
-        ParanoidModel.after_restore  :after_restore_callback
-        ParanoidModel.after_commit   :after_commit_callback
-
-        @model.should_receive(:before_restore_callback).once
-        @model.should_receive(:after_restore_callback).once
-        @model.should_receive(:after_commit_callback).once.and_return(true)
-
-        @model.restore!
-      end
-
-      it 'not call callbacks without restore.' do
-        ParanoidModel.before_update :before_update_callback
-        ParanoidModel.before_save   :before_save_callback
-        ParanoidModel.validate      :validate_callback
-
-        @model.should_receive(:before_update_callback).exactly(0).times
-        @model.should_receive(:before_save_callback).exactly(0).times
-        @model.should_receive(:validate_callback).exactly(0).times
-
-        @model.restore!
-      end
-
-      it 'alias recover to restore!' do
-        expect{
-          @model.restore!
-        }.to change(ParanoidModel, :count).by(1)
-
-        expect(@model.reload.destroyed?).to be_false
-      end
-    end
-  end
-end