mr 0.35.2

data/test/unit/after_commit/fake_record_tests.rb

@@ -0,0 +1,110 @@
+require 'assert'
+require 'mr/after_commit/fake_record'
+
+require 'much-plugin'
+require 'mr/after_commit'
+require 'mr/fake_record'
+
+module MR::AfterCommit::FakeRecord
+
+  class UnitTests < Assert::Context
+    desc "FakeRecord"
+    subject{ MR::AfterCommit::FakeRecord }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "when mixed in"
+    setup do
+      @fake_record_class = Class.new do
+        include MR::AfterCommit::FakeRecord
+      end
+    end
+    subject{ @fake_record_class }
+
+    should "be an MR record" do
+      assert_includes MR::FakeRecord, subject
+    end
+
+    should "use the records procs methods mixin" do
+      assert_includes MR::AfterCommit::RecordProcsMethods, subject
+    end
+
+  end
+
+  class InitTests < MixinTests
+    desc "and init"
+    setup do
+      @fake_record = @fake_record_class.new
+
+      i = 0
+      @fake_record.add_after_commit_proc(:save){   @save_call_num   = i += 1 }
+      @fake_record.add_after_commit_proc(:create){ @create_call_num = i += 1 }
+      @fake_record.add_after_commit_proc(:update){ @update_call_num = i += 1 }
+
+      @destroy_called = false
+      @fake_record.add_after_commit_proc(:destroy){ @destroy_called = true }
+    end
+    subject{ @fake_record }
+
+    should have_imeths :called_after_commit_procs
+
+    should "call and clear its save and create procs when a new fake record is saved" do
+      subject.save!
+
+      assert_equal 1, @create_call_num
+      assert_equal 2, @save_call_num
+      assert_nil @update_call_num
+      assert_false @destroy_called
+
+      assert_empty subject.after_commit_procs(:create, :save)
+      assert_not_empty subject.after_commit_procs(:update, :destroy)
+
+      assert_equal 1, subject.called_after_commit_procs(:create).size
+      assert_equal 1, subject.called_after_commit_procs(:save).size
+      assert_equal 0, subject.called_after_commit_procs(:update).size
+      assert_equal 0, subject.called_after_commit_procs(:destroy).size
+    end
+
+    should "call and clear its save and update procs when an existing fake record is saved" do
+      subject.id = Factory.integer # make it an existing
+      subject.save!
+
+      assert_equal 1, @update_call_num
+      assert_equal 2, @save_call_num
+      assert_nil @create_call_num
+      assert_false @destroy_called
+
+      assert_empty subject.after_commit_procs(:update, :save)
+      assert_not_empty subject.after_commit_procs(:create, :destroy)
+
+      assert_equal 1, subject.called_after_commit_procs(:update).size
+      assert_equal 1, subject.called_after_commit_procs(:save).size
+      assert_equal 0, subject.called_after_commit_procs(:create).size
+      assert_equal 0, subject.called_after_commit_procs(:destroy).size
+    end
+
+    should "call and clear its destroy procs after commit on destroy" do
+      subject.destroy
+
+      assert_true @destroy_called
+      assert_nil @save_call_num
+      assert_nil @create_call_num
+      assert_nil @update_call_num
+
+      assert_empty subject.after_commit_procs(:destroy)
+      assert_not_empty subject.after_commit_procs(:create, :update, :save)
+
+      assert_equal 1, subject.called_after_commit_procs(:destroy).size
+      assert_equal 0, subject.called_after_commit_procs(:update).size
+      assert_equal 0, subject.called_after_commit_procs(:save).size
+      assert_equal 0, subject.called_after_commit_procs(:create).size
+    end
+
+  end
+
+end

data/test/unit/after_commit/record_procs_methods_tests.rb

@@ -0,0 +1,177 @@
+require 'assert'
+require 'mr/after_commit/record_procs_methods'
+
+module MR::AfterCommit::RecordProcsMethods
+
+  class UnitTests < Assert::Context
+    desc "MR::AfterCommit::RecordProcsMethods"
+    subject{ MR::AfterCommit::RecordProcsMethods }
+
+    should "know its valid callback types" do
+      exp = [
+        :create,
+        :update,
+        :save,
+        :destroy
+      ]
+      assert_equal exp, VALID_CALLBACK_TYPES
+    end
+
+    should "know its default callback type" do
+      assert_equal :save, DEFAULT_CALLBACK_TYPE
+    end
+
+  end
+
+  class MixinAndInitTests < UnitTests
+    desc "when mixed in and init"
+    setup do
+      record_class = Class.new do
+        include MR::AfterCommit::RecordProcsMethods
+      end
+      @record = record_class.new
+    end
+    subject{ @record }
+
+    should have_imeths :after_commit_procs
+    should have_imeths :add_after_commit_proc, :prepend_after_commit_proc
+    should have_imeths :clear_after_commit_procs
+
+    should "not have any after commit procs by default" do
+      assert_equal [], subject.after_commit_procs
+      assert_equal [], subject.after_commit_procs(VALID_CALLBACK_TYPES.sample)
+    end
+
+    should "allow adding after commit procs" do
+      callback_type = VALID_CALLBACK_TYPES.sample
+      callback_proc = proc{ Factory.string }
+      subject.add_after_commit_proc(callback_type, &callback_proc)
+
+      assert_equal 1, subject.after_commit_procs.size
+      assert_includes callback_proc, subject.after_commit_procs
+      assert_equal 1, subject.after_commit_procs(callback_type).size
+      assert_includes callback_proc, subject.after_commit_procs(callback_type)
+    end
+
+    should "add the after commit proc to save by default" do
+      callback_proc = proc{ Factory.string }
+      subject.add_after_commit_proc(&callback_proc)
+
+      assert_equal 1, subject.after_commit_procs.size
+      assert_includes callback_proc, subject.after_commit_procs
+      assert_equal 1, subject.after_commit_procs(DEFAULT_CALLBACK_TYPE).size
+      assert_includes callback_proc, subject.after_commit_procs(DEFAULT_CALLBACK_TYPE)
+    end
+
+    should "append after commit procs when adding them" do
+      callback_type = VALID_CALLBACK_TYPES.sample
+      callbacks_procs = Factory.integer(3).times.map do
+        cp = proc{ Factory.string }
+        subject.add_after_commit_proc(callback_type, &cp)
+        cp
+      end
+
+      assert_equal callbacks_procs, subject.after_commit_procs(callback_type)
+    end
+
+    should "allow prepending after commit procs" do
+      callback_type = VALID_CALLBACK_TYPES.sample
+      callbacks_procs = Factory.integer(3).times.map do
+        cp = proc{ Factory.string }
+        subject.prepend_after_commit_proc(callback_type, &cp)
+        cp
+      end
+
+      exp = callbacks_procs.reverse
+      assert_equal exp, subject.after_commit_procs(callback_type)
+    end
+
+    should "prepend after commit procs to save by default" do
+      callback_proc = proc{ Factory.string }
+      subject.prepend_after_commit_proc(&callback_proc)
+
+      assert_equal 1, subject.after_commit_procs.size
+      assert_includes callback_proc, subject.after_commit_procs
+      assert_equal 1, subject.after_commit_procs(DEFAULT_CALLBACK_TYPE).size
+      assert_includes callback_proc, subject.after_commit_procs(DEFAULT_CALLBACK_TYPE)
+    end
+
+    should "allow getting after commit procs" do
+      callbacks_hash = VALID_CALLBACK_TYPES.inject({}) do |h, ct|
+        cps = Factory.integer(3).times.map do
+          cp = proc{ Factory.string }
+          subject.add_after_commit_proc(ct, &cp)
+          cp
+        end
+        h.merge!(ct => cps)
+      end
+
+      callback_type, exp = callbacks_hash.to_a.sample
+      assert_equal exp, subject.after_commit_procs(callback_type)
+
+      callback_types = callbacks_hash.keys.shuffle[0, 2]
+      exp = callback_types.map{ |ct| callbacks_hash[ct] }.flatten
+      assert_equal exp, subject.after_commit_procs(*callback_types)
+    end
+
+    should "allow clearing after commit procs" do
+      VALID_CALLBACK_TYPES.each do |ct|
+        Factory.integer(3).times.each do
+          subject.add_after_commit_proc(ct){ Factory.string }
+        end
+      end
+
+      callback_types = VALID_CALLBACK_TYPES.shuffle[0, 2]
+      assert_not_empty subject.after_commit_procs(*callback_types)
+      subject.clear_after_commit_procs(*callback_types)
+      assert_empty subject.after_commit_procs(*callback_types)
+
+      assert_not_empty subject.after_commit_procs
+      subject.clear_after_commit_procs
+      assert_empty subject.after_commit_procs
+    end
+
+    should "provide a helper for calling after commit procs" do
+      callback_type   = VALID_CALLBACK_TYPES.sample
+      callback_called = false
+      callback_proc   = proc{ callback_called = true }
+      subject.add_after_commit_proc(callback_type, &callback_proc)
+
+      subject.instance_eval{ mr_after_commit_call_procs(callback_type) }
+      assert_true callback_called
+      assert_equal [], subject.after_commit_procs(callback_type)
+      assert_equal [callback_proc], subject.called_after_commit_procs(callback_type)
+    end
+
+    should "allow checking which after commit procs have been called" do
+      callback_type = VALID_CALLBACK_TYPES.sample
+      callback_proc = proc{ Factory.string }
+      subject.add_after_commit_proc(callback_type, &callback_proc)
+
+      assert_equal [], subject.called_after_commit_procs
+      assert_equal [], subject.called_after_commit_procs(callback_type)
+
+      subject.instance_eval{ mr_after_commit_call_procs(callback_type) }
+
+      assert_equal [callback_proc], subject.called_after_commit_procs
+      assert_equal [callback_proc], subject.called_after_commit_procs(callback_type)
+    end
+
+    should "raise an argument error when using an invalid callback type" do
+      assert_raises(ArgumentError) do
+        subject.add_after_commit_proc(Factory.string.to_sym){ Factory.string }
+      end
+      assert_raises(ArgumentError) do
+        subject.prepend_after_commit_proc(Factory.string.to_sym){ Factory.string }
+      end
+      assert_raises(ArgumentError) do
+        subject.after_commit_procs(Factory.string.to_sym)
+      end
+      assert_raises(ArgumentError) do
+        subject.called_after_commit_procs(Factory.string.to_sym)
+      end
+    end
+
+  end
+
+end

data/test/unit/after_commit/record_tests.rb

@@ -0,0 +1,134 @@
+require 'assert'
+require 'mr/after_commit/record'
+
+require 'ardb/record_spy'
+require 'much-plugin'
+require 'mr/record'
+
+module MR::AfterCommit::Record
+
+  class UnitTests < Assert::Context
+    desc "MR::AfterCommit::Record"
+    subject{ MR::AfterCommit::Record }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "when mixed in"
+    setup do
+      @record_class = Ardb::RecordSpy.new do
+        include MR::AfterCommit::Record
+      end
+    end
+    subject{ @record_class }
+
+    should "be an MR record" do
+      assert_includes MR::Record, subject
+    end
+
+    should "use the records procs methods mixin" do
+      assert_includes MR::AfterCommit::RecordProcsMethods, subject
+    end
+
+    should "add an after commit callback on create" do
+      callback = subject.callbacks.find do |c|
+        c.type == :after_commit && c.options[:on] == :create
+      end
+
+      assert_not_nil callback
+      assert_equal :mr_after_commit_call_procs_for_create, callback.args.first
+    end
+
+    should "add an after commit callback on update" do
+      callback = subject.callbacks.find do |c|
+        c.type == :after_commit && c.options[:on] == :update
+      end
+
+      assert_not_nil callback
+      assert_equal :mr_after_commit_call_procs_for_update, callback.args.first
+    end
+
+    should "add an after commit callback on destroy" do
+      callback = subject.callbacks.find do |c|
+        c.type == :after_commit && c.options[:on] == :destroy
+      end
+
+      assert_not_nil callback
+      assert_equal :mr_after_commit_call_procs_for_destroy, callback.args.first
+    end
+
+  end
+
+  class InitTests < MixinTests
+    desc "and init"
+    setup do
+      @record = @record_class.new
+
+      i = 0
+      @record.add_after_commit_proc(:save){   @save_call_num   = i += 1 }
+      @record.add_after_commit_proc(:create){ @create_call_num = i += 1 }
+      @record.add_after_commit_proc(:update){ @update_call_num = i += 1 }
+
+      @destroy_called = false
+      @record.add_after_commit_proc(:destroy){ @destroy_called = true }
+    end
+    subject{ @record }
+
+    should "call and clear its save and create procs after commit on create" do
+      subject.instance_eval{ mr_after_commit_call_procs_for_create }
+
+      assert_equal 1, @create_call_num
+      assert_equal 2, @save_call_num
+      assert_nil @update_call_num
+      assert_false @destroy_called
+
+      assert_empty subject.after_commit_procs(:create, :save)
+      assert_not_empty subject.after_commit_procs(:update, :destroy)
+
+      assert_equal 1, subject.called_after_commit_procs(:create).size
+      assert_equal 1, subject.called_after_commit_procs(:save).size
+      assert_equal 0, subject.called_after_commit_procs(:update).size
+      assert_equal 0, subject.called_after_commit_procs(:destroy).size
+    end
+
+    should "call and clear its save and update procs after commit on update" do
+      subject.instance_eval{ mr_after_commit_call_procs_for_update }
+
+      assert_equal 1, @update_call_num
+      assert_equal 2, @save_call_num
+      assert_nil @create_call_num
+      assert_false @destroy_called
+
+      assert_empty subject.after_commit_procs(:update, :save)
+      assert_not_empty subject.after_commit_procs(:create, :destroy)
+
+      assert_equal 1, subject.called_after_commit_procs(:update).size
+      assert_equal 1, subject.called_after_commit_procs(:save).size
+      assert_equal 0, subject.called_after_commit_procs(:create).size
+      assert_equal 0, subject.called_after_commit_procs(:destroy).size
+    end
+
+    should "call and clear its destroy procs after commit on destroy" do
+      subject.instance_eval{ mr_after_commit_call_procs_for_destroy }
+
+      assert_true @destroy_called
+      assert_nil @save_call_num
+      assert_nil @create_call_num
+      assert_nil @update_call_num
+
+      assert_empty subject.after_commit_procs(:destroy)
+      assert_not_empty subject.after_commit_procs(:create, :update, :save)
+
+      assert_equal 1, subject.called_after_commit_procs(:destroy).size
+      assert_equal 0, subject.called_after_commit_procs(:update).size
+      assert_equal 0, subject.called_after_commit_procs(:save).size
+      assert_equal 0, subject.called_after_commit_procs(:create).size
+    end
+
+  end
+
+end

data/test/unit/after_commit_tests.rb

@@ -0,0 +1,113 @@
+require 'assert'
+require 'mr/after_commit'
+
+require 'much-plugin'
+require 'mr/after_commit/fake_record'
+require 'mr/after_commit/record_procs_methods'
+require 'mr/model'
+
+module MR::AfterCommit
+
+  class UnitTests < Assert::Context
+    desc "MR::AfterCommit"
+    subject{ MR::AfterCommit }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+    should "know its valid callback types" do
+      exp = RecordProcsMethods::VALID_CALLBACK_TYPES
+      assert_equal exp, VALID_CALLBACK_TYPES
+    end
+
+    should "know its default callback type" do
+      exp = RecordProcsMethods::DEFAULT_CALLBACK_TYPE
+      assert_equal exp, DEFAULT_CALLBACK_TYPE
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "when mixed in"
+    setup do
+      @model_class = Class.new do
+        include MR::AfterCommit
+      end
+    end
+    subject{ @model_class }
+
+    should "be an MR model" do
+      assert_includes MR::Model, subject
+    end
+
+  end
+
+  class InitTests < MixinTests
+    desc "and init"
+    setup do
+      @fake_record_class = Class.new do
+        include MR::AfterCommit::FakeRecord
+      end
+      @fake_record = @fake_record_class.new
+
+      @model = @model_class.new(@fake_record)
+    end
+    subject{ @model }
+
+    should have_imeths :after_commit_procs, :after_commit, :prepend_after_commit
+    should have_imeths :clear_after_commit_procs, :called_after_commit_procs
+
+    should "demeter it's record" do
+      callback_type, callback_proc = add_after_commit_proc
+
+      assert_includes callback_proc, subject.after_commit_procs(callback_type)
+      exp = @fake_record.after_commit_procs(callback_type)
+      assert_equal exp, subject.after_commit_procs(callback_type)
+
+      subject.clear_after_commit_procs(callback_type)
+      assert_equal [], subject.after_commit_procs(callback_type)
+
+      callback_procs = Factory.integer(3).times.map do
+        callback_type, callback_proc = add_after_commit_proc
+        callback_proc
+      end
+
+      callback_procs.each do |callback_proc|
+        assert_includes callback_proc, subject.after_commit_procs
+      end
+      assert_equal @fake_record.after_commit_procs, subject.after_commit_procs
+
+      subject.clear_after_commit_procs
+      assert_equal [], subject.after_commit_procs
+
+      callback_procs = Factory.integer(3).times.map do
+        callback_type, callback_proc = add_after_commit_proc
+        callback_proc
+      end
+
+      assert_equal [], subject.called_after_commit_procs
+      subject.save # create
+      subject.save # update
+      subject.destroy
+      callback_procs.each do |callback_proc|
+        assert_includes callback_proc, subject.called_after_commit_procs
+      end
+    end
+
+    private
+
+    def add_after_commit_proc
+      callback_type = VALID_CALLBACK_TYPES.sample
+      callback_proc = proc{ Factory.string }
+      if Factory.boolean
+        subject.after_commit(callback_type, &callback_proc)
+      else
+        subject.prepend_after_commit(callback_type, &callback_proc)
+      end
+      [callback_type, callback_proc]
+    end
+
+  end
+
+end