concurrent-ruby 0.0.1 → 0.1.0

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require_relative 'thread_pool_shared'
+
+module Concurrent
+
+  describe FixedThreadPool do
+
+    subject { FixedThreadPool.new(5) }
+
+    it_should_behave_like 'Thread Pool'
+
+    context '#initialize' do
+
+      it 'raises an exception when the pool size is less than one' do
+        lambda {
+          FixedThreadPool.new(0)
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'raises an exception when the pool size is greater than 1024' do
+        lambda {
+          FixedThreadPool.new(1025)
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'creates a thread pool of the given size' do
+        thread = double('thread')
+        # add one for the garbage collector
+        Thread.should_receive(:new).exactly(5+1).times.and_return(thread)
+        pool = FixedThreadPool.new(5)
+        pool.size.should eq 5
+      end
+
+      it 'aliases Concurrent#new_fixed_thread_pool' do
+        pool = Concurrent.new_fixed_thread_pool(5)
+        pool.should be_a(FixedThreadPool)
+        pool.size.should eq 5
+      end
+    end
+
+    context '#kill' do
+
+      it 'kills all threads' do
+        Thread.should_receive(:kill).exactly(5).times
+        pool = FixedThreadPool.new(5)
+        pool.kill
+        sleep(0.1)
+      end
+    end
+
+    context '#size' do
+
+      let(:pool_size) { 3 }
+      subject { FixedThreadPool.new(pool_size) }
+
+      it 'returns the size of the subject when running' do
+        subject.size.should eq pool_size
+      end
+
+      it 'returns zero while shutting down' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.size.should eq 0
+      end
+
+      it 'returns zero once shut down' do
+        subject.shutdown
+        subject.size.should eq 0
+      end
+    end
+
+    context 'exception handling' do
+
+      it 'restarts threads that experience exception' do
+        pool = FixedThreadPool.new(5)
+        3.times{ pool << proc{ raise StandardError } }
+        sleep(2)
+        pool.size.should eq 5
+        pool.status.should_not include(nil)
+        #pool.status.include?(nil).should be_false
+      end
+    end
+  end
+end

data/spec/concurrent/future_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require_relative 'obligation_shared'
+
+module Concurrent
+
+  describe Future do
+
+    let!(:fulfilled_value) { 10 }
+    let!(:rejected_reason) { StandardError.new('mojo jojo') }
+
+    let(:pending_subject) do
+      Future.new{ sleep(2) }
+    end
+
+    let(:fulfilled_subject) do
+      Future.new{ fulfilled_value }.tap(){ sleep(0.1) }
+    end
+
+    let(:rejected_subject) do
+      Future.new{ raise rejected_reason }.tap(){ sleep(0.1) }
+    end
+
+    before(:each) do
+      $GLOBAL_THREAD_POOL = CachedThreadPool.new
+    end
+
+    it_should_behave_like Obligation
+
+    context 'behavior' do
+
+      it 'implements :future behavior' do
+        lambda {
+          Future.new{ nil }
+        }.should_not raise_error
+
+        Future.new{ nil }.behaves_as?(:future).should be_true
+      end
+    end
+
+    context '#initialize' do
+
+      it 'spawns a new thread when a block is given' do
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        Future.new{ nil }
+      end
+
+      it 'does not spawns a new thread when no block given' do
+        Thread.should_not_receive(:new).with(any_args())
+        Future.new
+      end
+
+      it 'immediately sets the state to :fulfilled when no block given' do
+        Future.new.should be_fulfilled
+      end
+
+      it 'immediately sets the value to nil when no block given' do
+        Future.new.value.should be_nil
+      end
+    end
+
+    context 'fulfillment' do
+
+      it 'passes all arguments to handler' do
+        @a = @b = @c = nil
+        f = Future.new(1, 2, 3) do |a, b, c|
+          @a, @b, @c = a, b, c
+        end
+        sleep(0.1)
+        [@a, @b, @c].should eq [1, 2, 3]
+      end
+
+      it 'sets the value to the result of the handler' do
+        f = Future.new(10){|a| a * 2 }
+        sleep(0.1)
+        f.value.should eq 20
+      end
+
+      it 'sets the state to :fulfilled when the block completes' do
+        f = Future.new(10){|a| a * 2 }
+        sleep(0.1)
+        f.should be_fulfilled
+      end
+
+      it 'sets the value to nil when the handler raises an exception' do
+        f = Future.new{ raise StandardError }
+        sleep(0.1)
+        f.value.should be_nil
+      end
+
+      it 'sets the state to :rejected when the handler raises an exception' do
+        f = Future.new{ raise StandardError }
+        sleep(0.1)
+        f.should be_rejected
+      end
+
+      context 'aliases' do
+
+        it 'aliases #realized? for #fulfilled?' do
+          fulfilled_subject.should be_realized
+        end
+
+        it 'aliases #deref for #value' do
+          fulfilled_subject.deref.should eq fulfilled_value
+        end
+
+        it 'aliases Kernel#future for Future.new' do
+          future().should be_a(Future)
+          future(){ nil }.should be_a(Future)
+          future(1, 2, 3).should be_a(Future)
+          future(1, 2, 3){ nil }.should be_a(Future)
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/goroutine_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe '#go' do
+
+    before(:each) do
+      $GLOBAL_THREAD_POOL = CachedThreadPool.new
+    end
+
+    it 'passes all arguments to the block' do
+      @expected = nil
+      go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
+      sleep(0.1)
+      @expected.should eq [3, 2, 1]
+    end
+
+    it 'returns true if the thread is successfully created' do
+      $GLOBAL_THREAD_POOL.should_receive(:post).and_return(true)
+      go{ nil }.should be_true
+    end
+
+    it 'returns false if the thread cannot be created' do
+      $GLOBAL_THREAD_POOL.should_receive(:post).and_return(false)
+      go{ nil }.should be_false
+    end
+
+    it 'immediately returns false if no block is given' do
+      go().should be_false
+    end
+
+    it 'does not create a thread if no block is given' do
+      $GLOBAL_THREAD_POOL.should_not_receive(:post)
+      go()
+      sleep(0.1)
+    end
+
+    it 'supresses exceptions on the thread' do
+      lambda{
+        go{ raise StandardError }
+        sleep(0.1)
+      }.should_not raise_error
+    end
+
+    it 'processes the block' do
+      @expected = false
+      go(1,2,3){|*args| @expected = args }
+      sleep(0.1)
+      @expected.should eq [1,2,3]
+    end
+  end
+end

data/spec/concurrent/obligation_shared.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module Concurrent
+
+  share_examples_for Obligation do
+
+    context '#state' do
+
+      it 'is :pending when first created' do
+        f = pending_subject
+        f.state.should == :pending
+        f.should be_pending
+      end
+
+      it 'is :fulfilled when the handler completes' do
+        f = fulfilled_subject
+        f.state.should == :fulfilled
+        f.should be_fulfilled
+      end
+
+      it 'is :rejected when the handler raises an exception' do
+        f = rejected_subject
+        f.state.should == :rejected
+        f.should be_rejected
+      end
+    end
+
+    context '#value' do
+
+      it 'blocks the caller when :pending and timeout is nil' do
+        f = pending_subject
+        sleep(0.1)
+        f.value.should be_true
+        f.should be_fulfilled
+      end
+
+      it 'returns nil when reaching the optional timeout value' do
+        f = pending_subject
+        sleep(0.1)
+        f.value(0.1).should be_nil
+        f.should be_pending
+      end
+
+      it 'returns immediately when timeout is zero' do
+        Timeout.should_not_receive(:timeout).with(any_args())
+        f = pending_subject
+        sleep(0.1)
+        f.value(0).should be_nil
+        f.should be_pending
+      end
+
+      it 'is nil when :pending' do
+        expected = pending_subject.value
+        expected.should be_nil
+      end
+
+      it 'is nil when :rejected' do
+        expected = rejected_subject.value
+        expected.should be_nil
+      end
+
+      it 'is set to the return value of the block when :fulfilled' do
+        expected = fulfilled_subject.value
+        expected.should eq fulfilled_value
+      end
+    end
+
+    context '#reason' do
+
+      it 'is nil when :pending' do
+        pending_subject.reason.should be_nil
+      end
+
+      it 'is nil when :fulfilled' do
+        fulfilled_subject.reason.should be_nil
+      end
+
+      it 'is set to error object of the exception when :rejected' do
+        rejected_subject.reason.should be_a(Exception)
+        rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
+      end
+    end
+
+    context 'Kernel aliases' do
+
+      it 'aliases Kernel#deref for #deref' do
+        deref(fulfilled_subject).should eq fulfilled_value
+        deref(fulfilled_subject, 0).should eq fulfilled_value
+      end
+
+      it 'aliases Kernel#pending? for #pending?' do
+        #NOTE: was structured like others but was incorrectly failing
+        # on fulfilled_subject
+        fulfilled_subject.should_receive(:pending?).once
+        pending?(fulfilled_subject)
+        pending_subject.should_receive(:pending?).once
+        pending?(pending_subject)
+        rejected_subject.should_receive(:pending?).once
+        pending?(rejected_subject)
+      end
+
+      it 'aliases Kernel#fulfilled? for #fulfilled?' do
+        fulfilled?(fulfilled_subject).should be_true
+        fulfilled?(pending_subject).should be_false
+        fulfilled?(rejected_subject).should be_false
+      end
+
+      it 'aliases Kernel#realized? for #realized?' do
+        realized?(fulfilled_subject).should be_true
+        realized?(pending_subject).should be_false
+        realized?(rejected_subject).should be_false
+      end
+
+      it 'aliases Kernel#rejected? for #rejected?' do
+        rejected?(rejected_subject).should be_true
+        rejected?(fulfilled_subject).should be_false
+        rejected?(pending_subject).should be_false
+      end
+    end
+  end
+end

data/spec/concurrent/promise_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+require_relative 'obligation_shared'
+
+module Concurrent
+
+  describe Promise do
+
+    let!(:fulfilled_value) { 10 }
+    let!(:rejected_reason) { StandardError.new('mojo jojo') }
+
+    let(:pending_subject) do
+      Promise.new{ sleep(1) }
+    end
+
+    let(:fulfilled_subject) do
+      Promise.new{ fulfilled_value }.tap(){ sleep(0.1) }
+    end
+
+    let(:rejected_subject) do
+      Promise.new{ raise rejected_reason }.
+        rescue{ nil }.tap(){ sleep(0.1) }
+    end
+
+    before(:each) do
+      $GLOBAL_THREAD_POOL = CachedThreadPool.new
+    end
+
+    it_should_behave_like Obligation
+
+    context 'behavior' do
+
+      it 'implements :promise behavior' do
+        lambda {
+          Promise.new{ nil }
+        }.should_not raise_error
+
+        Promise.new{ nil }.behaves_as?(:promise).should be_true
+      end
+
+      it 'implements :future behavior' do
+        lambda {
+          Promise.new{ nil }
+        }.should_not raise_error
+
+        Promise.new{ nil }.behaves_as?(:future).should be_true
+      end
+    end
+
+    context '#then' do
+
+      it 'returns a new Promise when :pending' do
+        p1 = pending_subject
+        p2 = p1.then{}
+        p2.should be_a(Promise)
+        p1.should_not eq p2
+      end
+
+      it 'returns a new Promise when :fulfilled' do
+        p1 = fulfilled_subject
+        p2 = p1.then{}
+        p2.should be_a(Promise)
+        p1.should_not eq p2
+      end
+
+      it 'returns a new Promise when :rejected' do
+        p1 = rejected_subject
+        p2 = p1.then{}
+        p2.should be_a(Promise)
+        p1.should_not eq p2
+      end
+
+      it 'immediately rejects new promises when self has been rejected' do
+        p = rejected_subject
+        p.then.should be_rejected
+      end
+
+      it 'accepts a nil block' do
+        lambda {
+          pending_subject.then
+        }.should_not raise_error
+      end
+
+      it 'can be called more than once' do
+        p = pending_subject
+        p1 = p.then{}
+        p2 = p.then{}
+        p1.object_id.should_not eq p2.object_id
+      end
+    end
+
+    context '#rescue' do
+
+      it 'returns self when a block is given' do
+        p1 = pending_subject
+        p2 = p1.rescue{}
+        p1.object_id.should eq p2.object_id
+      end
+
+      it 'returns self when no block is given' do
+        p1 = pending_subject
+        p2 = p1.rescue
+        p1.object_id.should eq p2.object_id
+      end
+
+      it 'accepts an exception class as the first parameter' do
+        lambda {
+          pending_subject.rescue(StandardError){}
+        }.should_not raise_error
+      end
+    end
+
+    context 'fulfillment' do
+
+      it 'passes all arguments to the first promise in the chain' do
+        @a = @b = @c = nil
+        p = Promise.new(1, 2, 3) do |a, b, c|
+          @a, @b, @c = a, b, c
+        end
+        sleep(0.1)
+        [@a, @b, @c].should eq [1, 2, 3]
+      end
+
+      it 'passes the result of each block to all its children' do
+        @expected = nil
+        Promise.new(10){|a| a * 2 }.then{|result| @expected = result}
+        sleep(0.1)
+        @expected.should eq 20
+      end
+
+      it 'sets the promise value to the result if its block' do
+        p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
+        sleep(0.1)
+        p.value.should eq 40
+      end
+
+      it 'sets the promise state to :fulfilled if the block completes' do
+        p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
+        sleep(0.1)
+        p.should be_fulfilled
+      end
+
+      it 'passes the last result through when a promise has no block' do
+        @expected = nil
+        Promise.new(10){|a| a * 2 }.then.then{|result| @expected = result}
+        sleep(0.1)
+        @expected.should eq 20
+      end
+    end
+
+    context 'rejection' do
+
+      it 'sets the promise reason the error object on exception' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        sleep(0.1)
+        p.reason.should be_a(Exception)
+        p.reason.should.to_s =~ /Boom!/
+      end
+
+      it 'sets the promise state to :rejected on exception' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        sleep(0.1)
+        p.should be_rejected
+      end
+
+      it 'recursively rejects all children' do
+        p = Promise.new{ Thread.pass; raise StandardError.new('Boom!') }
+        promises = 10.times.collect{ p.then{ true } }
+        sleep(0.1)
+
+        10.times.each{|i| promises[i].should be_rejected }
+      end
+
+      it 'skips processing rejected promises' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        promises = 3.times.collect{ p.then{ true } }
+        sleep(0.1)
+        promises.each{|p| p.value.should_not be_true }
+      end
+
+      it 'calls the first exception block with a matching class' do
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(StandardError){|ex| @expected = 1 }.
+          rescue(StandardError){|ex| @expected = 2 }.
+          rescue(StandardError){|ex| @expected = 3 }
+          sleep(0.1)
+        @expected.should eq 1
+      end
+
+      it 'matches all with a rescue with no class given' do
+        @expected = nil
+        Promise.new{ raise NoMethodError }.
+          rescue(LoadError){|ex| @expected = 1 }.
+          rescue{|ex| @expected = 2 }.
+          rescue(StandardError){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 2
+      end
+
+      it 'searches associated rescue handlers in order' do
+        @expected = nil
+        Promise.new{ raise ArgumentError }.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 1
+
+        @expected = nil
+        Promise.new{ raise LoadError }.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 2
+
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 3
+      end
+
+      it 'passes the exception object to the matched block' do
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(ArgumentError){|ex| @expected = ex }.
+          rescue(LoadError){|ex| @expected = ex }.
+          rescue(Exception){|ex| @expected = ex }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'ignores rescuers without a block' do
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(StandardError).
+          rescue(StandardError){|ex| @expected = ex }.
+          rescue(Exception){|ex| @expected = ex }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'supresses the exception if no rescue matches' do
+        lambda {
+          Promise.new{ raise StandardError }.
+            rescue(ArgumentError){|ex| @expected = ex }.
+            rescue(StandardError){|ex| @expected = ex }.
+            rescue(Exception){|ex| @expected = ex }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+
+      it 'supresses exceptions thrown from rescue handlers' do
+        lambda {
+          Promise.new{ raise ArgumentError }.
+          rescue(Exception){ raise StandardError }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+
+      it 'calls matching rescue handlers on all children' do
+        @expected = []
+        Promise.new{ Thread.pass; raise StandardError }.
+          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
+          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
+          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
+          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
+          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }
+        sleep(0.1)
+
+        @expected.length.should eq 5
+      end
+    end
+
+    context 'aliases' do
+
+      it 'aliases #realized? for #fulfilled?' do
+        fulfilled_subject.should be_realized
+      end
+
+      it 'aliases #deref for #value' do
+        fulfilled_subject.deref.should eq fulfilled_value
+      end
+
+      it 'aliases #catch for #rescue' do
+        @expected = nil
+        Promise.new{ raise StandardError }.catch{ @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'aliases #on_error for #rescue' do
+        @expected = nil
+        Promise.new{ raise StandardError }.on_error{ @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'aliases Kernel#promise for Promise.new' do
+        promise().should be_a(Promise)
+        promise(){ nil }.should be_a(Promise)
+        promise(1, 2, 3).should be_a(Promise)
+        promise(1, 2, 3){ nil }.should be_a(Promise)
+      end
+    end
+  end
+end