deferred 0.5.3

data/spec/deferred/instance_methods_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+
+describe 'Deferred::InstanceMethods' do
+  # test Deferred::Default, as it mixes this in
+  
+  before do
+    @dd = Deferred::Default.new
+  end
+
+  it %[should set a callback and return self] do
+    cb_called = nil
+
+    rval = @dd.callback { cb_called = true }
+    rval.should == @dd
+
+    @dd.succeed
+    cb_called.should be_true
+  end
+
+  it %[should set an errback and return self] do
+    eb_called = nil
+
+    rval = @dd.errback { eb_called = true }
+    rval.should == @dd
+
+    @dd.fail
+    eb_called.should be_true
+  end
+
+  describe 'ensure_that' do
+    before do
+      @block_called = false
+      @rval = @dd.ensure_that { @block_called = true }
+    end
+
+    it %[should return self] do
+      @rval.should == @dd
+    end
+
+    it %[should set a callback] do
+      @dd.succeed
+      @block_called.should be_true
+    end
+
+    it %[should set an errback] do
+      @dd.fail
+      @block_called.should be_true
+    end
+  end
+
+  describe 'errback_on_exception' do
+    it %[should fire the errback with the exception instance as an argument] do
+      @dd.errback do |exc|
+        exc.should be_instance_of(RuntimeError)
+      end
+
+      @dd.errback_on_exception do
+        raise "Oh noes!"
+      end
+    end
+
+    it %[should do the right thing when errback is a proc] do
+      eb = proc do |exc|
+        exc.should be_instance_of(RuntimeError)
+      end
+
+      @dd.errback(&eb)
+
+      @dd.errback_on_exception do
+        raise "Oh noes!"
+      end
+    end
+
+    it %[should do the right thing when errback is a lambda] do
+      eb = lambda do |exc|
+        exc.should be_instance_of(RuntimeError)
+      end
+
+      @dd.errback(&eb)
+
+      @dd.errback_on_exception do
+        raise "Oh noes!"
+      end
+    end
+  end
+
+  describe 'timeout' do
+    include EventedSpec::SpecHelper 
+    default_timeout 1.0
+
+    class TestTimeoutError < StandardError; end
+    class OtherTestTimeoutError < StandardError; end
+
+    it %[should fire the errback with no arguments if an exception_klass is not given] do
+      @dd.errback do |*a|
+        a.should be_empty
+        done
+      end
+
+      em do
+        @dd.timeout(0.01)
+      end
+    end
+
+    it %[should fire the errback with an instance of the given klass if given] do
+      @dd.errback do |*a|
+        a.length.should == 1
+        exc = a.first
+        exc.should be_kind_of(TestTimeoutError)
+        exc.backtrace.should_not be_nil
+
+        done
+      end
+
+      em do
+        @dd.timeout(0.01, TestTimeoutError)
+      end
+      
+    end
+
+    # make sure this is compatible with the rest of EM::Deferrable
+    it %[should not fire the timeout if cancel_timeout is called] do
+      @dd.errback  { raise "This should not have been called" }
+      @dd.callback { done }
+
+      em do
+        @dd.timeout(0.3)  # set the timeout
+
+        delayed(0.1) { @dd.cancel_timeout }
+        delayed(0.4) { @dd.succeed }
+      end
+    end
+
+    it %[should reset the timeout if timeout is called a second time] do
+      @dd.errback do |e|
+        e.should be_kind_of(OtherTestTimeoutError)
+        done
+      end
+
+      em do
+        @dd.timeout(0.2, TestTimeoutError) # set the first timeout
+
+        # cancel the first timeout before it can fire, raise a different error
+        delayed(0.1) { @dd.timeout(0, OtherTestTimeoutError) } 
+      end
+    end
+  end # describe timeout
+
+  describe 'chain_to' do
+    before do
+      @one = Deferred::Default.new
+      @two = Deferred::Default.new
+    end
+
+    it %[should call the second's callbacks with the results of the first] do
+      @two.chain_to(@one)
+
+      callback_called = nil
+
+      @two.callback do |*args|
+        args.should_not be_empty
+        args.first.should == 'boogers'
+        callback_called = true
+      end
+
+      @one.succeed('boogers')
+      callback_called.should be_true
+    end
+
+    it %[should call the second's errbacks with the fail of the first] do
+      @two.chain_to(@one)
+
+      errback_called = nil
+
+      @two.errback do |*args|
+        args.should_not be_empty
+        args.first.should == 'boogers'
+        errback_called = true
+      end
+
+      @one.fail('boogers')
+      errback_called.should be_true
+    end
+
+    it %[should return self] do
+      @two.chain_to(@one).should == @two
+    end
+
+    it %[should not add the errback if :ignore_errors is true] do
+      @two.chain_to(@one, :ignore_errors => true)
+      
+      one_errback_called = two_errback_called = false
+
+      @two.callback do |*a|
+        callback_called = true
+      end
+
+      @two.errback do |*args|
+        args.should_not be_empty
+        args.first.should == 'boogers'
+        two_errback_called = true
+      end
+
+      @one.errback do |*a|
+        one_errback_called = true
+      end
+
+      @one.fail('boogers')
+      one_errback_called.should be_true
+      two_errback_called.should be_false
+    end
+
+    it %[should add the errback if :only_errors is true] do
+      @two.chain_to(@one, :only_errors => true)
+      
+      one_errback_called = two_errback_called = false
+
+      @one.errback do |*a|
+        one_errback_called = true
+      end
+
+      @two.errback do |*args|
+        args.should_not be_empty
+        args.first.should == 'boogers'
+        two_errback_called = true
+      end
+
+      @one.fail('boogers')
+
+      one_errback_called.should be_true
+      two_errback_called.should be_true
+    end
+
+    it %[should not add the callback if :only_errors is true] do
+      @two.chain_to(@one, :only_errors => true)
+
+      one_errback_called = two_errback_called = 
+        one_callback_called = two_callback_called = false
+
+      @one.errback  { |*| one_errback_called  = true }
+      @one.callback { |*| one_callback_called = true }
+      @two.errback  { |*| two_errback_called  = true }
+      @two.callback { |*| two_callback_called = true }
+
+      @one.succeed('boogers')
+
+      one_callback_called.should be_true
+      two_callback_called.should be_false
+    end
+  end
+
+  describe 'chain_err' do
+    before do
+      @one = Deferred::Default.new
+      @two = Deferred::Default.new
+    end
+
+    it %[should chain the errbacks] do
+      @two.chain_to(@one, :only_errors => true)
+      
+      one_errback_called = two_errback_called = false
+
+      @one.errback do |*a|
+        one_errback_called = true
+      end
+
+      @two.errback do |*args|
+        args.should_not be_empty
+        args.first.should == 'boogers'
+        two_errback_called = true
+      end
+
+      @one.fail('boogers')
+
+      one_errback_called.should be_true
+      two_errback_called.should be_true
+    end
+
+    it %[should not add the callback if :only_errors is true] do
+      @two.chain_to(@one, :only_errors => true)
+
+      one_errback_called = two_errback_called = 
+        one_callback_called = two_callback_called = false
+
+      @one.errback  { |*| one_errback_called  = true }
+      @one.callback { |*| one_callback_called = true }
+      @two.errback  { |*| two_errback_called  = true }
+      @two.callback { |*| two_callback_called = true }
+
+      @one.succeed('boogers')
+
+      one_callback_called.should be_true
+      two_callback_called.should be_false
+    end
+  end
+end
+

data/spec/deferred/threadpool_job_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe Deferred::ThreadpoolJob do
+
+  describe 'defer!' do
+    include EventedSpec::SpecHelper 
+    default_timeout 3.0
+
+    it %[should barf with an OnRunBlockNotRegisteredError if on_run was not called] do
+      tpj = Deferred::DefaultThreadpoolJob.new
+      lambda { tpj.defer! }.should raise_error(Deferred::OnRunBlockNotRegisteredError)
+    end
+
+    it %[should use a block passed to new as the on_run_block] do
+      orb = lambda { $stderr.puts "hooray!" }
+      tpj = Deferred::DefaultThreadpoolJob.new(&orb)
+
+      tpj.on_run_block.should == orb
+    end
+
+    describe 'success' do
+      before do
+        @rval = %w[foo bar]
+        @tpj = Deferred::DefaultThreadpoolJob.new { @rval }
+      end
+
+      it %[should call the callback if the block succeeds] do
+        cb_called = false
+
+        @tpj.callback do |result|
+          cb_called = true
+          result.should == @rval
+          done
+        end
+
+        em do
+          @tpj.defer!
+        end
+
+        cb_called.should be_true
+      end
+
+      it %[should fire the before_run callbacks before deferring the job] do
+        cb_ary = []
+
+        @tpj.before_run do
+          cb_ary << :before_run
+        end
+
+        @tpj.callback do |*a|
+          cb_ary << :after_run
+        end
+
+        @tpj.ensure_that do
+          cb_ary.should == [:before_run, :after_run]
+          done
+        end
+
+        em do
+          @tpj.defer!
+        end
+      end
+    end
+
+    describe 'failure' do
+      before do
+        @tpj = Deferred::DefaultThreadpoolJob.new { raise BollocksError }
+      end
+
+      it %[should fire the errbacks in the chain] do
+        @tpj.errback do |exc|
+          exc.should be_instance_of(BollocksError)
+          done
+        end
+
+        em do
+          @tpj.defer!
+        end
+      end
+    end   # describe 'failure'
+
+    describe 'on_run returns a ThreadpoolJob' do
+      describe 'success' do
+        before do
+          @rval = %w[one two]
+          @sub_job = Deferred::DefaultThreadpoolJob.new { @rval }
+          @first_job = Deferred::DefaultThreadpoolJob.new { @sub_job }
+        end
+
+        it %[should return the sub_job rval to the callback] do
+          @first_job.callback do |result|
+            result.should == @rval
+            done
+          end
+
+          em { @first_job.defer! }
+        end # it
+      end   # describe 'success'
+
+      describe 'failure' do
+        before do
+          @rval = %w[one two]
+          @sub_job = Deferred::DefaultThreadpoolJob.new { raise BollocksError }
+          @first_job = Deferred::DefaultThreadpoolJob.new { @sub_job }
+        end
+
+        it %[should fire the errback on the first_job] do
+          @first_job.errback do |exc|
+            exc.should be_instance_of(BollocksError)
+            done
+          end
+
+          em { @first_job.defer! }
+        end
+      end
+
+      describe 'before_run' do
+
+        it %[should call the before_run callbacks in the reactor thread] do
+          rval = "hooray"
+
+          sub_job = Deferred::DefaultThreadpoolJob.new { rval }
+
+          sub_job.before_run { EM.reactor_thread?.should be_true }
+          sub_job.callback { |*| done }
+
+          first_job = Deferred::DefaultThreadpoolJob.new { sub_job }
+
+          em { first_job.defer! }
+        end
+      end
+    end     # describe returns a ThreadpoolJob
+
+    describe 'on_run returns a Deferred' do
+      before do
+        @rval       = %w[one two]
+        @deferred   = Deferred::Default.new
+        @sub_job    = Deferred::DefaultThreadpoolJob.new { @deferred }
+        @first_job  = Deferred::DefaultThreadpoolJob.new { @sub_job }
+      end
+
+      it %[should chain the deferred's callback] do
+        EM.next_tick do
+          @deferred.succeed(*@rval)
+        end
+
+        @first_job.callback do |*a|
+          a.should == @rval
+          done
+        end
+
+        em { @first_job.defer! }
+      end
+
+      it %[should chain the deferred's errback] do
+        exc = BollocksError.new
+
+        @first_job.errback do |e|
+          e.should == exc
+          done
+        end
+
+        EM.next_tick do
+          @deferred.fail(exc)
+        end
+
+        em { @first_job.defer! }
+      end
+    end
+  end       # describe 'defer!'
+end
+