concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/spec/concurrent/simple_actor_ref_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+require_relative 'actor_ref_shared'
+
+module Concurrent
+
+  describe SimpleActorRef do
+
+    after(:each) do
+      subject.shutdown
+      sleep(0.1)
+    end
+
+    subject do
+      shared_actor_test_class.spawn
+    end
+
+    it_should_behave_like :actor_ref
+
+    context 'construction' do
+
+      it 'supports :args being nil' do
+        subject = shared_actor_test_class.spawn
+        actor = subject.instance_variable_get(:@actor)
+        actor.argv.should be_empty
+      end
+
+      it 'passes all :args option to the actor constructor' do
+        subject = shared_actor_test_class.spawn(args: [1, 2, 3, 4])
+        actor = subject.instance_variable_get(:@actor)
+        actor.argv.should eq [1, 2, 3, 4]
+      end
+
+      it 'passes the options hash to the ActorRef constructor' do
+        subject # prevent the after(:all) block from breaking this test
+        opts = {foo: :bar, hello: :world}
+        described_class.should_receive(:new).once.with(anything, opts)
+        shared_actor_test_class.spawn(opts)
+      end
+    end
+
+    context 'supervision' do
+
+      it 'does not start a new thread on construction' do
+        Thread.should_not_receive(:new).with(any_args)
+        subject = shared_actor_test_class.spawn
+      end
+
+      it 'starts a new thread on the first post' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).once.with(no_args).and_return(thread)
+        subject << :foo
+      end
+
+      it 'does not start a new thread after the first post' do
+        subject << :foo
+        sleep(0.1)
+        expected = Thread.list.length
+        5.times{ subject << :foo }
+        Thread.list.length.should eq expected
+      end
+
+      it 'starts a new thread when the prior thread has died' do
+        subject << :foo
+        sleep(0.1)
+
+        subject << :terminate
+        sleep(0.1)
+
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).once.with(no_args).and_return(thread)
+        subject << :foo
+      end
+
+      it 'does not reset the thread after shutdown' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).once.with(no_args).and_return(thread)
+        subject << :foo
+        sleep(0.1)
+
+        subject.shutdown
+        sleep(0.1)
+
+        subject << :foo
+      end
+
+      it 'calls #on_start when the thread is first started' do
+        actor = subject.instance_variable_get(:@actor)
+        actor.should_receive(:on_start).once.with(no_args)
+        subject << :foo
+      end
+
+      it 'calls #on_reset when the thread is started after the first time' do
+        actor = subject.instance_variable_get(:@actor)
+        actor.should_receive(:on_reset).once.with(no_args)
+        subject << :terminate
+        sleep(0.1)
+        subject << :foo
+      end
+    end
+
+    context 'abort_on_exception' do
+
+      after(:each) do
+        @ref.shutdown if @ref
+      end
+
+      it 'gets set on the actor thread' do
+        @ref = shared_actor_test_class.spawn(abort_on_exception: true)
+        @ref << :foo
+        sleep(0.1)
+        @ref.instance_variable_get(:@thread).abort_on_exception.should be_true
+
+        @ref = shared_actor_test_class.spawn(abort_on_exception: false)
+        @ref << :foo
+        sleep(0.1)
+        @ref.instance_variable_get(:@thread).abort_on_exception.should be_false
+      end
+
+      it 'defaults to true' do
+        @ref = shared_actor_test_class.spawn
+        @ref << :foo
+        sleep(0.1)
+        @ref.instance_variable_get(:@thread).abort_on_exception.should be_true
+      end
+    end
+
+    context 'reset_on_error' do
+
+      after(:each) do
+        @ref.shutdown if @ref
+      end
+
+      it 'causes #on_reset to be called on exception when true' do
+        @ref = shared_actor_test_class.spawn(reset_on_error: true)
+        actor = @ref.instance_variable_get(:@actor)
+        actor.should_receive(:on_reset).once.with(no_args)
+        @ref << :poison
+        sleep(0.1)
+      end
+
+      it 'prevents #on_reset form being called on exception when false' do
+        @ref = shared_actor_test_class.spawn(reset_on_error: false)
+        actor = @ref.instance_variable_get(:@actor)
+        actor.should_not_receive(:on_reset).with(any_args)
+        @ref << :poison
+        sleep(0.1)
+      end
+
+      it 'defaults to true' do
+        @ref = shared_actor_test_class.spawn
+        actor = @ref.instance_variable_get(:@actor)
+        actor.should_receive(:on_reset).once.with(no_args)
+        @ref << :poison
+        sleep(0.1)
+      end
+    end
+
+    context 'rescue_exception' do
+
+      after(:each) do
+        @ref.shutdown if @ref
+      end
+
+      it 'rescues Exception in the actor thread when true' do
+        @ref = shared_actor_test_class.spawn(
+          abort_on_exception: false,
+          rescue_exception: true
+        )
+
+        ivar = @ref.post(:poison)
+        sleep(0.1)
+        ivar.reason.should be_a StandardError
+
+        ivar = @ref.post(:bullet)
+        sleep(0.1)
+        ivar.reason.should be_a Exception
+      end
+
+      it 'rescues StandardError in the actor thread when false' do
+        @ref = shared_actor_test_class.spawn(
+          abort_on_exception: false,
+          rescue_exception: false
+        )
+
+        ivar = @ref.post(:poison)
+        sleep(0.1)
+        ivar.reason.should be_a StandardError
+
+        ivar = @ref.post(:bullet)
+        sleep(0.1)
+        ivar.reason.should be_nil
+      end
+
+      it 'defaults to false' do
+        @ref = shared_actor_test_class.spawn(abort_on_exception: false)
+
+        ivar = @ref.post(:poison)
+        sleep(0.1)
+        ivar.reason.should be_a StandardError
+
+        ivar = @ref.post(:bullet)
+        sleep(0.1)
+        ivar.reason.should be_nil
+      end
+    end
+
+    context '#shutdown' do
+
+      it 'calls #on_shutdown when shutdown' do
+        actor = subject.instance_variable_get(:@actor)
+        actor.should_receive(:on_shutdown).once.with(no_args)
+        subject << :foo
+        sleep(0.1)
+
+        subject.shutdown
+      end
+    end
+  end
+end

data/spec/concurrent/thread_pool_class_cast_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe ThreadPoolExecutor do
+    if jruby?
+      it 'inherits from JavaThreadPoolExecutor' do
+        ThreadPoolExecutor.ancestors.should include(JavaThreadPoolExecutor)
+      end
+    else
+      it 'inherits from RubyThreadPoolExecutor' do
+        ThreadPoolExecutor.ancestors.should include(RubyThreadPoolExecutor)
+      end
+    end
+  end
+
+  describe CachedThreadPool do
+    if jruby?
+      it 'inherits from JavaCachedThreadPool' do
+        CachedThreadPool.ancestors.should include(JavaCachedThreadPool)
+      end
+    else
+      it 'inherits from RubyCachedThreadPool' do
+        CachedThreadPool.ancestors.should include(RubyCachedThreadPool)
+      end
+    end
+  end
+
+  describe FixedThreadPool do
+    if jruby?
+      it 'inherits from JavaFixedThreadPool' do
+        FixedThreadPool.ancestors.should include(JavaFixedThreadPool)
+      end
+    else
+      it 'inherits from RubyFixedThreadPool' do
+        FixedThreadPool.ancestors.should include(RubyFixedThreadPool)
+      end
+    end
+  end
+end

data/spec/concurrent/thread_pool_executor_shared.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+require_relative 'thread_pool_shared'
+
+share_examples_for :thread_pool_executor do
+
+  after(:each) do
+    subject.kill
+    sleep(0.1)
+  end
+
+  it_should_behave_like :thread_pool
+
+  context '#initialize' do
+
+    it 'defaults :min_length to DEFAULT_MIN_POOL_SIZE' do
+      subject = described_class.new
+      subject.min_length.should eq described_class::DEFAULT_MIN_POOL_SIZE
+    end
+
+    it 'defaults :max_length to DEFAULT_MAX_POOL_SIZE' do
+      subject = described_class.new
+      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
+    end
+
+    it 'defaults :idletime to DEFAULT_THREAD_IDLETIMEOUT' do
+      subject = described_class.new
+      subject.idletime.should eq described_class::DEFAULT_THREAD_IDLETIMEOUT
+    end
+
+    it 'defaults :max_queue to DEFAULT_MAX_QUEUE_SIZE' do
+      subject = described_class.new
+      subject.max_queue.should eq described_class::DEFAULT_MAX_QUEUE_SIZE
+    end
+
+    it 'accepts all valid overflow policies' do
+      Concurrent::RubyThreadPoolExecutor::OVERFLOW_POLICIES.each do |policy|
+        subject = described_class.new(overflow_policy: policy)
+        subject.overflow_policy.should eq policy
+      end
+    end
+
+    it 'defaults :overflow_policy to :abort' do
+      subject = described_class.new
+      subject.overflow_policy.should eq :abort
+    end
+
+    it 'raises an exception if :min_threads is less than zero' do
+      expect {
+        described_class.new(min_threads: -1)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception if :max_threads is not greater than zero' do
+      expect {
+        described_class.new(max_threads: 0)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception if given an invalid :overflow_policy' do
+      expect {
+        described_class.new(overflow_policy: :bogus)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context '#max_queue' do
+
+    let!(:expected_max){ 100 }
+    subject{ described_class.new(max_queue: expected_max) }
+
+    it 'returns the set value on creation' do
+      subject.max_queue.should eq expected_max
+    end
+
+    it 'returns the set value when running' do
+      5.times{ subject.post{ sleep(0.1) } }
+      sleep(0.1)
+      subject.max_queue.should eq expected_max
+    end
+
+    it 'returns the set value after stopping' do
+      5.times{ subject.post{ sleep(0.1) } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.max_queue.should eq expected_max
+    end
+  end
+
+  context '#queue_length' do
+
+    let!(:expected_max){ 10 }
+    subject do
+      described_class.new(
+        min_threads: 2,
+        max_threads: 5,
+        max_queue: expected_max,
+        overflow_policy: :discard
+      )
+    end
+
+    it 'returns zero on creation' do
+      subject.queue_length.should eq 0
+    end
+
+    it 'returns zero when there are no enqueued tasks' do
+      5.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.queue_length.should eq 0
+    end
+
+    it 'returns the size of the queue when tasks are enqueued' do
+      100.times{ subject.post{ sleep(0.5) } }
+      sleep(0.1)
+      subject.queue_length.should > 0
+    end
+
+    it 'returns zero when stopped' do
+      100.times{ subject.post{ sleep(0.5) } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.queue_length.should eq 0
+    end
+
+    it 'can never be greater than :max_queue' do
+      100.times{ subject.post{ sleep(0.5) } }
+      sleep(0.1)
+      subject.queue_length.should <= expected_max
+    end
+  end
+
+  context '#remaining_capacity' do
+
+    let!(:expected_max){ 100 }
+    subject{ described_class.new(max_queue: expected_max) }
+
+    it 'returns -1 when :max_queue is set to zero' do
+      executor = described_class.new(max_queue: 0)
+      executor.remaining_capacity.should eq -1
+    end
+
+    it 'returns :max_length on creation' do
+      subject.remaining_capacity.should eq expected_max
+    end
+
+    it 'returns :max_length when stopped' do
+      100.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.remaining_capacity.should eq expected_max
+    end
+  end
+end

data/spec/concurrent/thread_pool_shared.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative 'global_thread_pool_shared'
 
 share_examples_for :thread_pool do
 
@@ -7,6 +8,79 @@ share_examples_for :thread_pool do
     sleep(0.1)
   end
 
+  it_should_behave_like :global_thread_pool
+
+  context '#scheduled_task_count' do
+
+    it 'returns zero on creation' do
+      subject.scheduled_task_count.should eq 0
+    end
+
+    it 'returns the approximate number of tasks that have been post thus far' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.scheduled_task_count.should > 0
+    end
+
+    it 'returns the approximate number of tasks that were post' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.scheduled_task_count.should > 0
+    end
+  end
+
+  context '#completed_task_count' do
+
+    it 'returns zero on creation' do
+      subject.completed_task_count.should eq 0
+    end
+
+    it 'returns the approximate number of tasks that have been completed thus far' do
+      5.times{ subject.post{ raise StandardError } }
+      5.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.completed_task_count.should > 0
+    end
+
+    it 'returns the approximate number of tasks that were completed' do
+      5.times{ subject.post{ raise StandardError } }
+      5.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.completed_task_count.should > 0
+    end
+  end
+
+  context '#length' do
+
+    it 'returns zero on creation' do
+      subject.length.should eq 0
+    end
+
+    it 'returns a non-zero while shutting down' do
+      5.times{ subject.post{ sleep(0.1) } }
+      subject.shutdown
+      subject.length.should > 0
+    end
+
+    it 'returns zero once shut down' do
+      5.times{ subject.post{ sleep(0.1) } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.length.should eq 0
+    end
+
+    it 'aliased as #current_length' do
+      5.times{ subject.post{ sleep(0.1) } }
+      sleep(0.1)
+      subject.current_length.should eq subject.length
+    end
+  end
+
   context '#running?' do
 
     it 'returns true when the thread pool is running' do
@@ -16,16 +90,19 @@ share_examples_for :thread_pool do
     it 'returns false when the thread pool is shutting down' do
       subject.post{ sleep(1) }
       subject.shutdown
+      subject.wait_for_termination(1)
       subject.should_not be_running
     end
 
     it 'returns false when the thread pool is shutdown' do
       subject.shutdown
+      subject.wait_for_termination(1)
       subject.should_not be_running
     end
 
     it 'returns false when the thread pool is killed' do
-      subject.shutdown
+      subject.kill
+      subject.wait_for_termination(1)
       subject.should_not be_running
     end
   end
@@ -83,55 +160,40 @@ share_examples_for :thread_pool do
       @expected.should be_false
     end
 
-    it 'attempts to kill all in-progress tasks' do
-      @expected = false
-      subject.post{ sleep(1); @expected = true }
-      sleep(0.1)
-      subject.kill
-      sleep(1)
-      @expected.should be_false
-    end
-
     it 'rejects all pending tasks' do
-      @expected = false
-      subject.post{ sleep(0.5) }
-      subject.post{ sleep(0.5); @expected = true }
+      subject.post{ sleep(1) }
       sleep(0.1)
       subject.kill
-      sleep(1)
-      @expected.should be_false
+      sleep(0.1)
+      subject.post{ nil }.should be_false
     end
 
     it 'kills all threads' do
-      before_thread_count = Thread.list.size
-      100.times { subject << proc{ sleep(1) } }
-      sleep(0.1)
-      Thread.list.size.should > before_thread_count
-      subject.kill
-      sleep(0.1)
-      Thread.list.size.should == before_thread_count
+      unless jruby? # this check is incorrect, want to check for class
+        pending('brittle test--counting threads is not reliable')
+        before_thread_count = Thread.list.size
+        100.times { subject << proc{ sleep(1) } }
+        sleep(0.1)
+        Thread.list.size.should > before_thread_count
+        subject.kill
+        sleep(0.1)
+        Thread.list.size.should == before_thread_count
+      end
     end
   end
 
   context '#wait_for_termination' do
 
-    it 'immediately returns true when no threads running' do
+    it 'immediately returns true when no operations are pending' do
       subject.shutdown
-      subject.wait_for_termination.should be_true
+      subject.wait_for_termination(0).should be_true
     end
 
     it 'returns true after shutdown has complete' do
-      10.times { subject << proc{ sleep(0.1) } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination.should be_true
-    end
-
-    it 'blocks indefinitely when timeout is nil' do
-      subject.post{ sleep(1) }
+      10.times { subject << proc{ nil } }
       sleep(0.1)
       subject.shutdown
-      subject.wait_for_termination(nil).should be_true
+      subject.wait_for_termination(1).should be_true
     end
 
     it 'returns true when shutdown sucessfully completes before timeout' do
@@ -142,10 +204,10 @@ share_examples_for :thread_pool do
     end
 
     it 'returns false when shutdown fails to complete before timeout' do
-      subject.post{ sleep }
+      (subject.length + 10).times{ subject.post{ sleep(1) } }
       sleep(0.1)
       subject.shutdown
-      subject.wait_for_termination(1).should be_false
+      subject.wait_for_termination(0).should be_false
     end
   end
 
@@ -158,7 +220,7 @@ share_examples_for :thread_pool do
     end
 
     it 'returns true when the block is added to the queue' do
-      subject.post{ sleep }.should be_true
+      subject.post{ nil }.should be_true
     end
 
     it 'calls the block with the given arguments' do