kakurenbo 0.1.3 → 0.2.0

data/lib/kakurenbo/version.rb

@@ -1,3 +1,3 @@
 module Kakurenbo
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/kakurenbo/cores/associations_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+#
+#               NormalChildModel         [has_many]
+# ParentModel < ParanoidChildModel       [has_many]
+#               ParanoidSingleChildModel [has_many][belongs_to]
+#
+describe Kakurenbo::Core do
+  create_temp_table(:parent_models)                { |t| t.integer :child_belongs_to_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 }
+
+  subject :subject_soft_delete do
+    create_unrelated_children
+    expect { parent.destroy! }.to change(child_class, :count).by(children.length * -1)
+  end
+
+  subject :subject_restore do
+    create_unrelated_children
+    expect { parent.destroy! }.to change(child_class, :count).by(children.length * -1)
+    expect { parent.restore! }.to change(child_class, :count).by(children.length)
+  end
+
+  subject :subject_not_restore do
+    parent.destroy!
+    expect { parent.restore! }.not_to change(child_class, :count)
+  end
+
+  let :create_unrelated_children do
+    [
+      child_class.create!,
+      child_class.create!,
+    ]
+  end
+
+  let :destroy_children do
+    children.each {|child| child.destroy!}
+  end
+
+  let :parent do
+    parent_class.create!
+  end
+
+  let :parent_class do
+    ParentModel.tap do |parent_class|
+      parent_class.has_many :normal_child_models,   :dependent => :destroy
+      parent_class.has_many :paranoid_child_models, :dependent => :destroy
+
+      parent_class.has_one     :child_has_one, :class_name => :ParanoidSingleChildModel, :dependent => :destroy
+      parent_class.belongs_to  :child_belongs_to, :class_name => :ParanoidSingleChildModel, :dependent => :destroy
+    end
+  end
+
+  describe 'NormalChildModel' do
+    let :child_class do
+      NormalChildModel
+    end
+
+    let :children do
+      [
+        parent.normal_child_models.create!,
+        parent.normal_child_models.create!,
+        parent.normal_child_models.create!,
+      ]
+    end
+
+    context 'when parent is destroyed' do
+      it 'related children will be destroyed.' do
+        subject_soft_delete
+      end
+    end
+  end
+
+  describe 'ParanoidChildModel(has_many)' do
+    let :child_class do
+      ParanoidChildModel
+    end
+
+    let :children do
+      [
+        parent.paranoid_child_models.create!,
+        parent.paranoid_child_models.create!,
+        parent.paranoid_child_models.create!,
+      ]
+    end
+
+    context 'when parent is destroyed' do
+      it 'related children will be destroyed.' do
+        subject_soft_delete
+      end
+    end
+
+    context 'when parent is restored' do
+      it 'related children will be restored.' do
+        subject_restore
+      end
+
+      context 'when children are deleted, before restore parent' do
+        before :each do
+          destroy_children
+        end
+
+        it 'related children will be not restored.' do
+          subject_not_restore
+        end
+      end
+    end
+  end
+
+  describe 'ParanoidSingleChildModel(has_one)' do
+    let :child_class do
+      ParanoidSingleChildModel
+    end
+
+    let :children do
+      [
+        parent.create_child_has_one!
+      ]
+    end
+
+    context 'when parent is destroyed' do
+      it 'related children will be destroyed.' do
+        subject_soft_delete
+      end
+    end
+
+    context 'when parent is restored' do
+      it 'related children will be restored.' do
+        subject_restore
+      end
+
+      context 'when children are deleted, before restore parent' do
+        before :each do
+          destroy_children
+        end
+
+        it 'related children will be not restored.' do
+          subject_not_restore
+        end
+      end
+    end
+  end
+
+  describe 'ParanoidSingleChildModel(has_one)' do
+    let :child_class do
+      ParanoidSingleChildModel
+    end
+
+    let :children do
+      [
+        parent.create_child_belongs_to!
+      ]
+    end
+
+    context 'when parent is destroyed' do
+      it 'related children will be destroyed.' do
+        subject_soft_delete
+      end
+    end
+
+    context 'when parent is restored' do
+      it 'related children will be restored.' do
+        subject_restore
+      end
+
+      context 'when children are deleted, before restore parent' do
+        before :each do
+          destroy_children
+        end
+
+        it 'related children will be not restored.' do
+          subject_not_restore
+        end
+      end
+    end
+  end
+end

data/spec/kakurenbo/cores/callbacks_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Kakurenbo::Core::Callbacks do
+  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
+  before :all do
+    ParanoidModel.tap do |klass|
+      klass.before_destroy    :callback_before_destroy
+      klass.after_destroy     :callback_after_destroy
+      klass.after_commit      :callback_after_commit
+
+      klass.before_restore    :callback_before_restore
+      klass.after_restore     :callback_after_restore
+
+      klass.before_update     :callback_before_update
+      klass.before_save       :callback_before_save
+      klass.before_validation :callback_before_validation
+    end
+  end
+
+  let! :model do
+    model_class.create!
+  end
+
+  let :model_class do
+    ParanoidModel.tap do |klass|
+      allow_any_instance_of(klass).to receive(:callback_before_destroy)    { true }
+      allow_any_instance_of(klass).to receive(:callback_after_destroy)     { true }
+      allow_any_instance_of(klass).to receive(:callback_after_commit)      { true }
+
+      allow_any_instance_of(klass).to receive(:callback_before_restore)    { true }
+      allow_any_instance_of(klass).to receive(:callback_after_restore)     { true }
+
+      allow_any_instance_of(klass).to receive(:callback_before_update)     { true }
+      allow_any_instance_of(klass).to receive(:callback_before_save)       { true }
+      allow_any_instance_of(klass).to receive(:callback_before_validation) { true }
+    end
+  end
+
+  context 'when call #delete' do
+    subject { model.delete }
+
+    it 'destroy-callbacks will not be called.' do
+      expect(model).not_to receive(:callback_before_destroy)
+      expect(model).not_to receive(:callback_after_destroy)
+      expect(model).not_to receive(:callback_after_commit)
+
+      subject
+    end
+
+    it 'save-callbacks will not be called.' do
+      expect(model).not_to receive(:callback_before_update)
+      expect(model).not_to receive(:callback_before_save)
+      expect(model).not_to receive(:callback_before_validation)
+
+      subject
+    end
+  end
+
+  context 'when call #destroy' do
+    subject { model.destroy }
+
+    it 'destroy-callbacks will be called.' do
+      expect(model).to receive(:callback_before_destroy).once
+      expect(model).to receive(:callback_after_destroy).once
+      expect(model).to receive(:callback_after_commit).once
+
+      subject
+    end
+
+    it 'save-callbacks will not be called.' do
+      expect(model).not_to receive(:callback_before_update)
+      expect(model).not_to receive(:callback_before_save)
+      expect(model).not_to receive(:callback_before_validation)
+
+      subject
+    end
+  end
+
+  context 'when call #restore' do
+    before :each do
+      model.destroy!
+    end
+
+    subject { model.restore }
+
+    it 'restore-callbacks will be called.' do
+      expect(model).to receive(:callback_before_restore).once
+      expect(model).to receive(:callback_after_restore).once
+      expect(model).to receive(:callback_after_commit).once
+
+      subject
+    end
+
+    it 'save-callbacks will not be called.' do
+      expect(model).not_to receive(:callback_before_update)
+      expect(model).not_to receive(:callback_before_save)
+      expect(model).not_to receive(:callback_before_validation)
+
+      subject
+    end
+  end
+end

data/spec/kakurenbo/cores/core_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Kakurenbo::Core do
+  create_temp_table(:paranoid_models){ |t| t.datetime :deleted_at }
+  before :all do
+    ParanoidModel.tap do |klass|
+      klass.before_destroy    :callback_before_destroy
+      klass.before_restore    :callback_before_restore
+    end
+  end
+
+  subject :subject_hard_delete do
+    expect {
+      subject
+    }.to change {
+      model_class.with_deleted.find_by(:id => model.id)
+    }.to(nil)
+  end
+
+  subject :subject_not_hard_delete do
+    expect {
+      subject
+    }.not_to change {
+      model_class.with_deleted.find_by(:id => model.id)
+    }
+  end
+
+  subject :subject_soft_delete do
+    expect { subject }.to change { model.reload.destroyed? }.from(false).to(true)
+  end
+
+  subject :subject_restore do
+    expect { subject }.to change { model.reload.destroyed? }.from(true).to(false)
+  end
+
+  let! :model do
+    model_class.create!
+  end
+
+  let :model_class do
+    ParanoidModel.tap do |klass|
+      allow_any_instance_of(klass).to receive(:callback_before_destroy)    { true }
+      allow_any_instance_of(klass).to receive(:callback_before_restore)    { true }
+    end
+  end
+
+  let :now do
+    Time.now.tap do |now|
+      allow(Time).to receive(:now) { now.dup }
+    end
+  end
+
+  describe '#delete' do
+    subject { model.delete }
+
+    it 'record will be soft-deleted.' do
+      subject_soft_delete
+    end
+
+    it 'record will not be hard-deleted.' do
+      subject_not_hard_delete
+    end
+
+    context 'when with hard-delete option' do
+      subject { model.delete(:hard => true) }
+
+      it 'record will be hard-deleted.' do
+        subject_hard_delete
+      end
+    end
+  end
+
+  describe '#destroy' do
+    subject { model.destroy }
+
+    it 'record will be soft-deleted.' do
+      subject_soft_delete
+    end
+
+    it 'record will not be hard-deleted.' do
+      subject_not_hard_delete
+    end
+
+    it 'return self' do
+      expect(subject).to eq(model)
+    end
+
+    context 'when action is cancelled' do
+      before :each do
+        allow(model).to receive(:callback_before_destroy) { false }
+      end
+
+      it 'record will not be soft-deleted.' do
+        expect { subject }.not_to change { model.reload.destroyed? }
+      end
+
+      it 'return falsey' do
+        expect(subject).to be_falsey
+      end
+    end
+
+    context 'when with hard-delete option' do
+      subject { model.destroy(:hard => true) }
+
+      it 'record will be hard-deleted.' do
+        subject_hard_delete
+      end
+    end
+  end
+
+  describe '#destroy!' do
+    subject { model.destroy! }
+    context 'when action is cancelled' do
+      before :each do
+        allow(model).to receive(:callback_before_destroy) { false }
+      end
+
+      it 'raise ActiveRecord::RecordNotDestroyed' do
+        expect{subject}.to raise_error(ActiveRecord::RecordNotDestroyed)
+      end
+    end
+  end
+
+  describe '#destroyed?' do
+    subject { model.destroyed? }
+
+    context 'when model not deleted' do
+      it 'return falsey' do
+        expect(subject).to be_falsey
+      end
+    end
+
+    context 'when model deleted' do
+      before :each do
+        model.destroy
+      end
+
+      it 'return truthy' do
+        expect(subject).to be_truthy
+      end
+    end
+  end
+
+  describe '#restore' do
+    before :each do
+      model.destroy
+    end
+
+    subject { model.restore }
+
+    it 'record will be restored.' do
+      subject_restore
+    end
+
+    it 'return self' do
+      expect(subject).to eq(model)
+    end
+
+    context 'when action is cancelled' do
+      before :each do
+        allow(model).to receive(:callback_before_restore) { false }
+      end
+
+      it 'record will not be restored.' do
+        expect { subject }.not_to change { model.reload.destroyed? }
+      end
+
+      it 'return falsey' do
+        expect(subject).to be_falsey
+      end
+    end
+  end
+
+  describe '#restore!' do
+    subject { model.restore! }
+    context 'when action is cancelled' do
+      before :each do
+        allow(model).to receive(:callback_before_restore) { false }
+      end
+
+      it 'raise ActiveRecord::RecordNotRestored' do
+        expect{subject}.to raise_error(ActiveRecord::RecordNotRestored)
+      end
+    end
+  end
+end