concurrent-ruby 0.3.2 → 0.4.0

data/spec/concurrent/channel_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require_relative 'postable_shared'
+require_relative 'runnable_shared'
+require_relative 'stoppable_shared'
+
+module Concurrent
+
+  describe Channel do
+
+    context :runnable do
+      subject{ Channel.new{ nil } }
+      it_should_behave_like :runnable
+    end
+
+    context :stoppable do
+      subject do
+        task = Channel.new{ nil }
+        task.run!
+        task
+      end
+      it_should_behave_like :stoppable
+    end
+
+    context :postable do
+
+      let!(:postable_class){ Channel }
+
+      let(:sender) do
+        Channel.new do |*message|
+          if message.first.is_a?(Exception)
+            raise message.first
+          else
+            message.first
+          end
+        end
+      end
+
+      let(:receiver){ Channel.new{|*message| message.first } }
+
+      it_should_behave_like :postable
+    end
+
+    subject{ Channel.new{ nil } }
+
+    context '#initialize' do
+
+      it 'raises an exception if no block is given' do
+        expect {
+          Channel.new
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#behavior' do
+
+      it 'calls the block once for each message' do
+        @expected = false
+        channel = Channel.new{ @expected = true }
+        channel.run!
+        channel << 42
+        sleep(0.1)
+        channel.stop
+        @expected.should be_true
+      end
+
+      it 'passes all arguments to the block' do
+        @expected = []
+        channel = Channel.new{|*message| @expected = message }
+        channel.run!
+        channel.post(1,2,3,4,5)
+        sleep(0.1)
+        channel.stop
+        @expected.should eq [1,2,3,4,5]
+      end
+    end
+
+    context '#pool' do
+
+      it 'passes a duplicate of the block to each channel in the pool' do
+        block = proc{ nil }
+        block.should_receive(:dup).exactly(5).times.and_return(proc{ nil })
+        mbox, pool = Channel.pool(5, &block)
+      end
+    end
+  end
+end

data/spec/concurrent/event_machine_defer_proxy_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 require 'concurrent/agent'
 require 'concurrent/future'
-require 'concurrent/goroutine'
 require 'concurrent/promise'
 
 if mri?
@@ -52,23 +51,6 @@ if mri?
 
       context 'operation' do
 
-        context 'goroutine' do
-
-          it 'passes all arguments to the block' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
-
-            EventMachine.run do
-
-              @expected = nil
-              go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
-              sleep(0.1)
-              @expected.should eq [3, 2, 1]
-
-              EventMachine.stop
-            end
-          end
-        end
-
         context Agent do
 
           subject { Agent.new(0) }

data/spec/concurrent/event_spec.rb

@@ -21,7 +21,7 @@ module Concurrent
       end
 
       it 'returns false if the event is unset' do
-        subject.reset
+        #subject.reset
         subject.should_not be_set
       end
     end
@@ -29,7 +29,7 @@ module Concurrent
     context '#set' do
 
       it 'triggers the event' do
-        subject.reset
+        #subject.reset
         @expected = false
         Thread.new{ subject.wait; @expected = true }
         sleep(0.1)
@@ -46,12 +46,47 @@ module Concurrent
 
     context '#reset' do
 
-      it 'sets the state to unset' do
+      it 'does not change the state of an unset event' do
+        subject.reset
+        subject.should_not be_set
+      end
+ 
+      it 'does not trigger an unset event' do
+        @expected = false
+        Thread.new{ subject.wait; @expected = true }
+        sleep(0.1)
+        subject.reset
+        sleep(0.1)
+        @expected.should be_false
+      end
+
+      it 'does not interrupt waiting threads when event is unset' do
+        @expected = false
+        Thread.new{ subject.wait; @expected = true }
+        sleep(0.1)
+        subject.reset
+        sleep(0.1)
+        subject.set
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'returns true when called on an unset event' do
+        subject.reset.should be_true
+      end
+
+      it 'sets the state of a set event to unset' do
         subject.set
         subject.should be_set
         subject.reset
         subject.should_not be_set
       end
+
+      it 'returns true when called on a set event' do
+        subject.set
+        subject.should be_set
+        subject.reset.should be_true
+      end
     end
 
     context '#wait' do

data/spec/concurrent/global_thread_pool_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'concurrent/goroutine'
 require_relative 'uses_global_thread_pool_shared'
 
 module Concurrent
@@ -62,23 +61,5 @@ module Concurrent
         subject << proc{ nil }
       end
     end
-
-    context 'operation' do
-
-      context 'goroutine' do
-
-        it 'gets a new thread' do
-          $GLOBAL_THREAD_POOL = subject
-
-          t = Thread.new{ nil }
-
-          Thread.should_receive(:new).with(no_args()).and_return(t)
-          go{ nil }
-
-          Thread.should_receive(:new).with(1,2,3).and_return(t)
-          go(1,2,3){ nil }
-        end
-      end
-    end
   end
 end

data/spec/concurrent/postable_shared.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+share_examples_for :postable do
+
+  after(:each) do
+    subject.stop
+    @thread.kill unless @thread.nil?
+    sleep(0.1)
+  end
+
+  context '#post' do
+
+    it 'raises an exception when the message is empty' do
+      expect {
+        subject.post
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'returns false when not running' do
+      subject.post(42).should be_false
+    end
+
+    it 'pushes a message onto the queue' do
+      @expected = false
+      postable = postable_class.new{|msg| @expected = msg }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      postable.post(true)
+      @thread.join(0.1)
+      @expected.should be_true
+      postable.stop
+    end
+
+    it 'returns the current size of the queue' do
+      postable = postable_class.new{|msg| sleep }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      postable.post(true).should == 1
+      @thread.join(0.1)
+      postable.post(true).should == 1
+      @thread.join(0.1)
+      postable.post(true).should == 2
+      postable.stop
+    end
+
+    it 'is aliased a <<' do
+      @expected = false
+      postable = postable_class.new{|msg| @expected = msg }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      postable << true
+      @thread.join(0.1)
+      @expected.should be_true
+      postable.stop
+    end
+  end
+
+  context '#post?' do
+
+    it 'returns nil when not running' do
+      subject.post?(42).should be_false
+    end
+
+    it 'returns an Obligation' do
+      postable = postable_class.new{ nil }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      obligation = postable.post?(nil)
+      obligation.should be_a(Concurrent::Obligation)
+      postable.stop
+    end
+
+    it 'fulfills the obligation on success' do
+      postable = postable_class.new{|msg| @expected = msg }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      obligation = postable.post?(42)
+      @thread.join(0.1)
+      obligation.should be_fulfilled
+      obligation.value.should == 42
+      postable.stop
+    end
+
+    it 'rejects the obligation on failure' do
+      postable = postable_class.new{|msg| raise StandardError.new('Boom!') }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      obligation = postable.post?(42)
+      @thread.join(0.1)
+      obligation.should be_rejected
+      obligation.reason.should be_a(StandardError)
+      postable.stop
+    end
+  end
+
+  context '#post!' do
+
+    it 'raises Concurrent::Runnable::LifecycleError when not running' do
+      expect {
+        subject.post!(1, 'Hello World!')
+      }.to raise_error(Concurrent::Runnable::LifecycleError)
+    end
+
+    it 'blocks for up to the given number of seconds' do
+      postable = postable_class.new{|msg| sleep }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      start = Time.now.to_i
+      expect {
+        postable.post!(2, nil)
+      }.to raise_error
+      elapsed = Time.now.to_i - start
+      elapsed.should >= 2
+      postable.stop
+    end
+
+    it 'raises Concurrent::TimeoutError when seconds is zero' do
+      postable = postable_class.new{|msg| 42 }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      expect {
+        postable.post!(0, nil)
+      }.to raise_error(Concurrent::TimeoutError)
+      postable.stop
+    end
+
+    it 'raises Concurrent::TimeoutError on timeout' do
+      postable = postable_class.new{|msg| sleep }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      expect {
+        postable.post!(1, nil)
+      }.to raise_error(Concurrent::TimeoutError)
+      postable.stop
+    end
+
+    it 'bubbles the exception on error' do
+      postable = postable_class.new{|msg| raise StandardError.new('Boom!') }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      expect {
+        postable.post!(1, nil)
+      }.to raise_error(StandardError)
+      postable.stop
+    end
+
+    it 'returns the result on success' do
+      postable = postable_class.new{|msg| 42 }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      expected = postable.post!(1, nil)
+      expected.should == 42
+      postable.stop
+    end
+
+    it 'attempts to cancel the operation on timeout' do
+      @expected = 0
+      postable = postable_class.new{|msg| sleep(0.5); @expected += 1 }
+      @thread = Thread.new{ postable.run }
+      @thread.join(0.1)
+      postable.post(nil) # block the postable
+      expect {
+        postable.post!(0.1, nil)
+      }.to raise_error(Concurrent::TimeoutError)
+      sleep(1.5)
+      @expected.should == 1
+      postable.stop
+    end
+  end
+
+  context '#forward' do
+
+    let(:observer) { double('observer') }
+
+    before(:each) do
+      @sender = Thread.new{ sender.run }
+      @receiver = Thread.new{ receiver.run }
+      @sender.join(0.1)
+      @receiver.join(0.1)
+    end
+
+    after(:each) do
+      sender.stop
+      receiver.stop
+      sleep(0.1)
+      @sender.kill unless @sender.nil?
+      @receiver.kill unless @receiver.nil?
+    end
+
+    it 'returns false when sender not running' do
+      sender.stop
+      sleep(0.1)
+      sender.forward(receiver, 'Hello World!').should be_false
+    end
+
+    it 'forwards the result to the receiver on success' do
+      receiver.should_receive(:post).with(42)
+      sender.forward(receiver, 42)
+      sleep(0.1)
+    end
+
+    it 'does not forward on exception' do
+      receiver.should_not_receive(:post).with(42)
+      sender.forward(receiver, StandardError.new)
+      sleep(0.1)
+    end
+
+    it 'notifies observers on success' do
+      observer.should_receive(:update).with(any_args())
+      sender.add_observer(observer)
+      sender.forward(receiver, 42)
+      sleep(0.1)
+    end
+
+    it 'notifies observers on exception' do
+      observer.should_not_receive(:update).with(any_args())
+      sender.add_observer(observer)
+      sender.forward(receiver, StandardError.new)
+      sleep(0.1)
+    end
+  end
+end

data/spec/concurrent/stoppable_shared.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+share_examples_for :stoppable do
+
+  after(:each) do
+    subject.stop
+  end
+
+  context 'stopping' do
+
+    it 'raises an exception when #before_stop does not receive a block' do
+      expect {
+        subject.before_stop
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception if #before_stop is called more than once' do
+      subject.before_stop{ nil }
+      expect {
+        subject.before_stop{ nil }
+      }.to raise_error(Concurrent::Runnable::LifecycleError)
+    end
+
+    it 'returns self from #before_stop' do
+      task = subject
+      task.before_stop{ nil }.should eq task
+    end
+
+    it 'calls the #before_stop block when stopping' do
+      @expected = false
+      subject.before_stop{ @expected = true }
+      subject.stop
+      sleep(0.1)
+      @expected.should be_true
+    end
+  end
+end