concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/spec/concurrent/event_machine_defer_proxy_spec.rb

@@ -86,7 +86,9 @@ if Functional::PLATFORM.mri?
               subject.post{ @expected << 2 }
               subject.post{ @expected << 3 }
               sleep(0.1)
-              @expected.should eq [1,2,3]
+              @expected.should include(1)
+              @expected.should include(2)
+              @expected.should include(3)
 
               EventMachine.stop
             end

data/spec/concurrent/event_spec.rb

@@ -54,25 +54,6 @@ module Concurrent
       end
     end
 
-    context '#pulse' do
-
-      it 'triggers the event' do
-        subject.reset
-        @expected = false
-        Thread.new{ subject.wait; @expected = true }
-        sleep(0.1)
-        subject.pulse
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'sets the state to unset' do
-        subject.pulse
-        sleep(0.1)
-        subject.should_not be_set
-      end
-    end
-
     context '#wait' do
 
       it 'returns immediately when the event has been set' do

data/spec/concurrent/executor_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative 'runnable_shared'
 
 module Concurrent
 
@@ -14,109 +15,194 @@ module Concurrent
     end
 
     after(:each) do
-      @ec.kill unless @ec.nil?
+      @subject = @subject.runner if @subject.respond_to?(:runner)
+      @subject.kill unless @subject.nil?
+      @thread.kill unless @thread.nil?
+      sleep(0.1)
     end
 
-    context '#run' do
+    context ':runnable' do
 
-      it 'raises an exception if no block given' do
-        lambda {
-          @ec = Concurrent::Executor.run('Foo')
-        }.should raise_error
-      end
+      subject { Executor.new(':runnable'){ nil } }
 
-      it 'uses the default execution interval when no interval is given' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.execution_interval.should eq Executor::EXECUTION_INTERVAL
-      end
+      it_should_behave_like :runnable
+    end
 
-      it 'uses the default timeout interval when no interval is given' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.timeout_interval.should eq Executor::TIMEOUT_INTERVAL
-      end
+    context 'created with #new' do
 
-      it 'uses the given execution interval' do
-        @ec = Executor.run('Foo', execution_interval: 5){ nil }
-        @ec.execution_interval.should eq 5
-      end
+      context '#initialize' do
 
-      it 'uses the given timeout interval' do
-        @ec = Executor.run('Foo', timeout_interval: 5){ nil }
-        @ec.timeout_interval.should eq 5
-      end
+        it 'raises an exception if no block given' do
+          lambda {
+            @subject = Concurrent::Executor.new('Foo')
+          }.should raise_error
+        end
+
+        it 'uses the default execution interval when no interval is given' do
+          @subject = Executor.new('Foo'){ nil }
+          @subject.execution_interval.should eq Executor::EXECUTION_INTERVAL
+        end
+
+        it 'uses the default timeout interval when no interval is given' do
+          @subject = Executor.new('Foo'){ nil }
+          @subject.timeout_interval.should eq Executor::TIMEOUT_INTERVAL
+        end
+
+        it 'uses the given execution interval' do
+          @subject = Executor.new('Foo', execution_interval: 5){ nil }
+          @subject.execution_interval.should eq 5
+        end
+
+        it 'uses the given timeout interval' do
+          @subject = Executor.new('Foo', timeout_interval: 5){ nil }
+          @subject.timeout_interval.should eq 5
+        end
 
-      it 'creates a new thread' do
-        thread = Thread.new{ sleep(1) }
-        Thread.should_receive(:new).with(any_args()).and_return(thread)
-        @ec = Executor.run('Foo'){ nil }
+        it 'sets the #name context variable' do
+          @subject = Executor.new('Foo'){ nil }
+          @subject.name.should eq 'Foo'
+        end
       end
 
-      it 'returns an ExecutionContext' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.should be_a(Executor::ExecutionContext)
+      context '#kill' do
+        pending
       end
 
-      it 'sets the #name context variable' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.name.should eq 'Foo'
+      context '#status' do
+
+        subject { Executor.new('Foo'){ nil } }
+
+        it 'returns the status of the executor thread when running' do
+          @thread = Thread.new { subject.run }
+          sleep(0.1)
+          subject.status.should eq 'sleep'
+        end
+
+        it 'returns nil when not running' do
+          subject.status.should be_nil
+        end
       end
     end
 
-    context 'execution' do
+    context 'created with Executor.run!' do
 
-      it 'runs the block immediately when the :run_now option is true' do
-        @expected = false
-        @ec = Executor.run('Foo', execution: 500, now: true){ @expected = true }
-        @expected.should be_false
-        sleep(1)
-        @expected.should be_true
-      end
+      context 'arguments' do
 
-      it 'waits for :execution_interval seconds when the :run_now option is false' do
-        @expected = false
-        @ec = Executor.run('Foo', execution: 0.5, now: false){ @expected = true }
-        @expected.should be_false
-        sleep(1)
-        @expected.should be_true
-      end
+        it 'raises an exception if no block given' do
+          lambda {
+            @subject = Concurrent::Executor.run('Foo')
+          }.should raise_error
+        end
 
-      it 'waits for :execution_interval seconds when the :run_now option is not given' do
-        @expected = false
-        @ec = Executor.run('Foo', execution: 0.5){ @expected = true }
-        @expected.should be_false
-        sleep(1)
-        @expected.should be_true
-      end
+        it 'passes the name to the new Executor' do
+          @subject = Executor.new('Foo'){ nil }
+          Executor.should_receive(:new).with('Foo').and_return(@subject)
+          Concurrent::Executor.run!('Foo')
+        end
 
-      it 'yields to the execution block' do
-        @expected = false
-        @ec = Executor.run('Foo', execution: 1){ @expected = true }
-        sleep(2)
-        @expected.should be_true
-      end
+        it 'passes the options to the new Executor' do
+          opts = {
+            execution_interval: 100,
+            timeout_interval: 100,
+            run_now: false,
+            logger: proc{ nil },
+            block_args: %w[one two three]
+          }
+          @subject = Executor.new('Foo', opts){ nil }
+          Executor.should_receive(:new).with(anything(), opts).and_return(@subject)
+          Concurrent::Executor.run!('Foo', opts)
+        end
 
-      it 'passes any given arguments to the execution block' do
-        args = [1,2,3,4]
-        @expected = nil
-        @ec = Executor.run('Foo', execution_interval: 0.5, args: args) do |*args|
-          @expected = args
+        it 'passes the block to the new Executor' do
+          @expected = false
+          block = proc{ @expected = true }
+          @subject = Executor.run!('Foo', run_now: true, &block)
+          sleep(0.1)
+          @expected.should be_true
+        end
+
+        it 'creates a new thread' do
+          thread = Thread.new{ sleep(1) }
+          Thread.should_receive(:new).with(any_args()).and_return(thread)
+          @subject = Executor.run!('Foo'){ nil }
         end
-        sleep(1)
-        @expected.should eq args
       end
 
-      it 'supresses exceptions thrown by the execution block' do
-        lambda {
-          @ec = Executor.run('Foo', execution_interval: 0.5) { raise StandardError }
+      context 'execution' do
+
+        it 'runs the block immediately when the :run_now option is true' do
+          @expected = false
+          @subject = Executor.run!('Foo', execution: 500, now: true){ @expected = true }
+          sleep(0.1)
+          @expected.should be_true
+        end
+
+        it 'waits for :execution_interval seconds when the :run_now option is false' do
+          @expected = false
+          @subject = Executor.run!('Foo', execution: 0.5, now: false){ @expected = true }
+          @expected.should be_false
+          sleep(1)
+          @expected.should be_true
+        end
+
+        it 'waits for :execution_interval seconds when the :run_now option is not given' do
+          @expected = false
+          @subject = Executor.run!('Foo', execution: 0.5){ @expected = true }
+          @expected.should be_false
+          sleep(1)
+          @expected.should be_true
+        end
+
+        it 'yields to the execution block' do
+          @expected = false
+          @subject = Executor.run!('Foo', execution: 1){ @expected = true }
+          sleep(2)
+          @expected.should be_true
+        end
+
+        it 'passes any given arguments to the execution block' do
+          args = [1,2,3,4]
+          @expected = nil
+          @subject = Executor.new('Foo', execution_interval: 0.5, args: args) do |*args|
+            @expected = args
+          end
+          @thread = Thread.new { @subject.run }
           sleep(1)
-        }.should_not raise_error
+          @expected.should eq args
+        end
+
+        it 'supresses exceptions thrown by the execution block' do
+          lambda {
+            @subject = Executor.new('Foo', execution_interval: 0.5) { raise StandardError }
+          @thread = Thread.new { @subject.run }
+            sleep(1)
+          }.should_not raise_error
+        end
+
+        it 'kills the worker thread if the timeout is reached' do
+          # the after(:each) block will trigger this expectation
+          Thread.should_receive(:kill).at_least(1).with(any_args())
+          @subject = Executor.new('Foo', execution_interval: 0.5, timeout_interval: 0.5){ Thread.stop }
+          @thread = Thread.new { @subject.run }
+          sleep(1.5)
+        end
       end
 
-      it 'kills the worker thread if the timeout is reached' do
-        # the after(:each) block will trigger this expectation
-        Thread.should_receive(:kill).at_least(1).with(any_args())
-        @ec = Executor.run('Foo', execution_interval: 0.5, timeout_interval: 0.5){ Thread.stop }
-        sleep(1.5)
+      context '#status' do
+
+        it 'returns the status of the executor thread when running' do
+          @subject = Executor.run!('Foo'){ nil }
+          sleep(0.1)
+          @subject.runner.status.should eq 'sleep'
+        end
+
+        it 'returns nil when not running' do
+          @subject = Executor.new('Foo'){ nil }
+          sleep(0.1)
+          @subject.kill
+          sleep(0.1)
+          @subject.status.should be_nil
+        end
       end
     end
 
@@ -135,66 +221,28 @@ module Concurrent
       end
 
       it 'uses a custom logger when given' do
-        @ec = Executor.run('Foo', execution_interval: 0.1, logger: @logger){ nil }
+        @subject = Executor.run!('Foo', execution_interval: 0.1, logger: @logger){ nil }
         sleep(0.5)
         @name.should eq 'Foo'
       end
 
       it 'logs :info when execution is successful' do
-        @ec = Executor.run('Foo', execution_interval: 0.1, logger: @logger){ nil }
+        @subject = Executor.run!('Foo', execution_interval: 0.1, logger: @logger){ nil }
         sleep(0.5)
         @level.should eq :info
       end
 
       it 'logs :warn when execution times out' do
-        @ec = Executor.run('Foo', execution_interval: 0.1, timeout_interval: 0.1, logger: @logger){ Thread.stop }
+        @subject = Executor.run!('Foo', execution_interval: 0.1, timeout_interval: 0.1, logger: @logger){ Thread.stop }
         sleep(0.5)
         @level.should eq :warn
       end
 
       it 'logs :error when execution is fails' do
-        @ec = Executor.run('Foo', execution_interval: 0.1, logger: @logger){ raise StandardError }
+        @subject = Executor.run!('Foo', execution_interval: 0.1, logger: @logger){ raise StandardError }
         sleep(0.5)
         @level.should eq :error
       end
     end
-
-    context '#status' do
-
-      it 'returns the status of the executor thread when running' do
-        @ec = Executor.run('Foo'){ nil }
-        sleep(0.1)
-        @ec.status.should eq 'sleep'
-      end
-
-      it 'returns nil when not running' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.kill
-        sleep(0.1)
-        @ec.status.should be_nil
-      end
-    end
-
-    context '#join' do
-
-      it 'joins the executor thread when running' do
-        @ec = Executor.run('Foo'){ nil }
-        Thread.new{ sleep(1); @ec.kill }
-        @ec.join.should be_a(Thread)
-      end
-
-      it 'joins the executor thread with timeout when running' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.join(1).should be_nil
-      end
-
-      it 'immediately returns nil when not running' do
-        @ec = Executor.run('Foo'){ nil }
-        @ec.kill
-        sleep(0.1)
-        @ec.join.should be_nil
-        @ec.join(1).should be_nil
-      end
-    end
   end
 end

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -7,7 +7,12 @@ module Concurrent
 
     subject { FixedThreadPool.new(5) }
 
-    it_should_behave_like 'Thread Pool'
+    after(:each) do
+      subject.kill
+      sleep(0.1)
+    end
+
+    it_should_behave_like :thread_pool
 
     context '#initialize' do
 
@@ -17,35 +22,11 @@ module Concurrent
         }.should raise_error(ArgumentError)
       end
 
-      it 'raises an exception when the pool size is greater than 1024' do
+      it 'raises an exception when the pool size is greater than MAX_POOL_SIZE' do
         lambda {
-          FixedThreadPool.new(1025)
+          FixedThreadPool.new(FixedThreadPool::MAX_POOL_SIZE + 1)
         }.should raise_error(ArgumentError)
       end
-
-      it 'creates a thread pool of the given size' do
-        thread = Thread.new{ nil }
-        # 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).at_least(5).times
-        pool = FixedThreadPool.new(5)
-        pool.kill
-        sleep(0.1)
-      end
     end
 
     context '#size' do
@@ -53,8 +34,17 @@ module Concurrent
       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
+      it 'returns zero on start' do
+        subject.shutdown
+        subject.size.should eq 0
+      end
+
+      it 'returns the size of the pool when running' do
+        pool_size.times do |i|
+          subject.post{ sleep }
+          sleep(0.1)
+          subject.size.should eq i+1
+        end
       end
 
       it 'returns zero while shutting down' do
@@ -69,11 +59,31 @@ module Concurrent
       end
     end
 
+    context 'worker creation and caching' do
+
+      it 'creates new workers when there are none available' do
+        pool = FixedThreadPool.new(5)
+        pool.size.should eq 0
+        5.times{ sleep(0.1); pool << proc{ sleep } }
+        sleep(0.1)
+        pool.size.should eq 5
+        pool.kill
+      end
+
+      it 'never creates more than :max_threads threads' do
+        pool = FixedThreadPool.new(5)
+        100.times{ sleep(0.01); pool << proc{ sleep } }
+        sleep(0.1)
+        pool.length.should eq 5
+        pool.kill
+      end
+    end
+
     context 'exception handling' do
 
       it 'restarts threads that experience exception' do
         pool = FixedThreadPool.new(5)
-        3.times{ pool << proc{ raise StandardError } }
+        5.times{ pool << proc{ raise StandardError } }
         sleep(5)
         pool.size.should eq 5
         pool.status.should_not include(nil)