concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/spec/concurrent/event_spec.rb

@@ -1,134 +1,134 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Event do
-
-    subject{ Event.new }
-
-    context '#initialize' do
-
-      it 'sets the state to unset' do
-        subject.should_not be_set
-      end
-    end
-
-    context '#set?' do
-
-      it 'returns true when the event has been set' do
-        subject.set
-        subject.should be_set
-      end
-
-      it 'returns false if the event is unset' do
-        subject.reset
-        subject.should_not be_set
-      end
-    end
-
-    context '#set' do
-
-      it 'triggers the event' do
-        subject.reset
-        @expected = false
-        Thread.new{ subject.wait; @expected = true }
-        sleep(0.1)
-        subject.set
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'sets the state to set' do
-        subject.set
-        subject.should be_set
-      end
-    end
-
-    context '#reset' do
-
-      it 'sets the state to unset' do
-        subject.set
-        subject.should be_set
-        subject.reset
-        subject.should_not be_set
-      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
-        subject.reset
-        @expected = false
-        subject.set
-        Thread.new{ subject.wait(1000); @expected = true}
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'returns true once the event is set' do
-        subject.set
-        subject.wait.should be_true
-      end
-
-      it 'blocks indefinitely when the timer is nil' do
-        subject.reset
-        @expected = false
-        Thread.new{ subject.wait; @expected = true}
-        subject.set
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'stops waiting when the timer expires' do
-        subject.reset
-        @expected = false
-        Thread.new{ subject.wait(0.5); @expected = true}
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'returns false when the timer expires' do
-        subject.reset
-        subject.wait(1).should be_false
-      end
-
-      it 'triggers multiple waiting threads' do
-        subject.reset
-        @expected = []
-        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
-        subject.set
-        sleep(1)
-        @expected.length.should eq 5
-      end
-
-      it 'behaves appropriately if wait begins while #set is processing' do
-        subject.reset
-        @expected = []
-        5.times{ Thread.new{ subject.wait(5) } }
-        subject.set
-        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
-        sleep(1)
-        @expected.length.should eq 5
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+
+  describe Event do
+
+    subject{ Event.new }
+
+    context '#initialize' do
+
+      it 'sets the state to unset' do
+        subject.should_not be_set
+      end
+    end
+
+    context '#set?' do
+
+      it 'returns true when the event has been set' do
+        subject.set
+        subject.should be_set
+      end
+
+      it 'returns false if the event is unset' do
+        subject.reset
+        subject.should_not be_set
+      end
+    end
+
+    context '#set' do
+
+      it 'triggers the event' do
+        subject.reset
+        @expected = false
+        Thread.new{ subject.wait; @expected = true }
+        sleep(0.1)
+        subject.set
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'sets the state to set' do
+        subject.set
+        subject.should be_set
+      end
+    end
+
+    context '#reset' do
+
+      it 'sets the state to unset' do
+        subject.set
+        subject.should be_set
+        subject.reset
+        subject.should_not be_set
+      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
+        subject.reset
+        @expected = false
+        subject.set
+        Thread.new{ subject.wait(1000); @expected = true}
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'returns true once the event is set' do
+        subject.set
+        subject.wait.should be_true
+      end
+
+      it 'blocks indefinitely when the timer is nil' do
+        subject.reset
+        @expected = false
+        Thread.new{ subject.wait; @expected = true}
+        subject.set
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'stops waiting when the timer expires' do
+        subject.reset
+        @expected = false
+        Thread.new{ subject.wait(0.5); @expected = true}
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'returns false when the timer expires' do
+        subject.reset
+        subject.wait(1).should be_false
+      end
+
+      it 'triggers multiple waiting threads' do
+        subject.reset
+        @expected = []
+        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
+        subject.set
+        sleep(1)
+        @expected.length.should eq 5
+      end
+
+      it 'behaves appropriately if wait begins while #set is processing' do
+        subject.reset
+        @expected = []
+        5.times{ Thread.new{ subject.wait(5) } }
+        subject.set
+        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
+        sleep(1)
+        @expected.length.should eq 5
+      end
+    end
+  end
+end

data/spec/concurrent/executor_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Executor do
+
+    before(:each) do
+      @orig_stdout = $stdout
+      $stdout = StringIO.new 
+    end
+
+    after(:each) do
+      $stdout = @orig_stdout
+    end
+
+    after(:each) do
+      @ec.kill unless @ec.nil?
+    end
+
+    context '#run' do
+
+      it 'raises an exception if no block given' do
+        lambda {
+          @ec = Concurrent::Executor.run('Foo')
+        }.should raise_error
+      end
+
+      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 '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
+
+      it 'uses the given execution interval' do
+        @ec = Executor.run('Foo', execution_interval: 5){ nil }
+        @ec.execution_interval.should eq 5
+      end
+
+      it 'uses the given timeout interval' do
+        @ec = Executor.run('Foo', timeout_interval: 5){ nil }
+        @ec.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 }
+      end
+
+      it 'returns an ExecutionContext' do
+        @ec = Executor.run('Foo'){ nil }
+        @ec.should be_a(Executor::ExecutionContext)
+      end
+
+      it 'sets the #name context variable' do
+        @ec = Executor.run('Foo'){ nil }
+        @ec.name.should eq 'Foo'
+      end
+    end
+
+    context 'execution' do
+
+      it 'waits for #execution_interval seconds before executing the block' do
+        @expected = false
+        @ec = 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
+        @ec = 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
+        @ec = Executor.run('Foo', execution_interval: 0.5, args: args) do |*args|
+          @expected = args
+        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 }
+          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())
+        @ec = Executor.run('Foo', execution_interval: 0.5, timeout_interval: 0.5){ Thread.stop }
+        sleep(1.5)
+      end
+    end
+
+    context 'logging' do
+
+      before(:each) do
+        @name = nil
+        @level = nil
+        @msg = nil
+
+        @logger = proc do |name, level, msg|
+          @name = name
+          @level = level
+          @msg = msg
+        end
+      end
+
+      it 'uses a custom logger when given' do
+        @ec = 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 }
+        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 }
+        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 }
+        sleep(0.5)
+        @level.should eq :error
+      end
+    end
+  end
+end

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -1,84 +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
+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).at_least(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