concurrent-ruby 0.0.1 → 0.1.0

data/spec/concurrent/defer_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Defer do
+
+    context '#initialize' do
+
+      before(:each) do
+        $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
+      end
+
+      it 'raises an exception if no block or operation given' do
+        lambda {
+          Defer.new
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if both a block and an operation given' do
+        lambda {
+          operation = proc{ nil }
+          Defer.new(operation, nil, nil){ nil }
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'starts the thread if an operation is given' do
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        operation = proc{ nil }
+        Defer.new(operation, nil, nil)
+      end
+
+      it 'does not start the thread if neither a callback or errorback is given' do
+        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        Defer.new(nil, nil, nil){ nil }
+      end
+
+      it 'aliases Kernel#defer' do
+        defer{ nil }.should be_a(Defer)
+      end
+    end
+
+    context '#then' do
+
+      it 'raises an exception if no block given' do
+        lambda {
+          Defer.new{ nil }.then
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if called twice' do
+        lambda {
+          Defer.new{ nil }.then{|result| nil }.then{|result| nil }
+        }.should raise_error(IllegalMethodCallError)
+      end
+
+      it 'raises an exception if an operation was provided at construction' do
+        lambda {
+          operation = proc{ nil }
+          Defer.new(operation, nil, nil).then{|result| nil }
+        }.should raise_error(IllegalMethodCallError)
+      end
+
+      it 'raises an exception if a callback was provided at construction' do
+        lambda {
+          callback = proc{|result|nil }
+          Defer.new(nil, callback, nil){ nil }.then{|result| nil }
+        }.should raise_error(IllegalMethodCallError)
+      end
+
+      it 'returns self' do
+        deferred = Defer.new{ nil }
+        deferred.then{|result| nil }.should eq deferred
+      end
+    end
+
+    context '#rescue' do
+
+      it 'raises an exception if no block given' do
+        lambda {
+          Defer.new{ nil }.rescue
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if called twice' do
+        lambda {
+          Defer.new{ nil }.rescue{ nil }.rescue{ nil }
+        }.should raise_error(IllegalMethodCallError)
+      end
+
+      it 'raises an exception if an operation was provided at construction' do
+        lambda {
+          operation = proc{ nil }
+          Defer.new(operation, nil, nil).rescue{|ex| nil }
+        }.should raise_error(IllegalMethodCallError)
+      end
+
+      it 'raises an exception if an errorback was provided at construction' do
+        lambda {
+          errorback = proc{|ex| nil }
+          Defer.new(nil, nil, errorback){ nil }.rescue{|ex| nil }
+        }.should raise_error(IllegalMethodCallError)
+      end
+
+      it 'returns self' do
+        deferred = Defer.new{ nil }
+        deferred.rescue{|ex| nil }.should eq deferred
+      end
+
+      it 'aliases #catch' do
+        lambda {
+          Defer.new{ nil }.catch{|ex| nil }
+        }.should_not raise_error
+      end
+
+      it 'aliases #on_error' do
+        lambda {
+          Defer.new{ nil }.on_error{|ex| nil }
+        }.should_not raise_error
+      end
+    end
+
+    context '#go' do
+
+      it 'starts the thread if not started' do
+        deferred = Defer.new{ nil }
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        deferred.go
+      end
+
+      it 'does nothing if called more than once' do
+        deferred = Defer.new{ nil }
+        deferred.go
+        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        deferred.go
+      end
+
+      it 'does nothing if thread started at construction' do
+        operation = proc{ nil }
+        callback = proc{|result| nil }
+        errorback = proc{|ex| nil }
+        deferred = Defer.new(operation, callback, errorback)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        deferred.go
+      end
+    end
+
+    context 'fulfillment' do
+
+      it 'runs the operation' do
+        @expected = false
+        Defer.new{ @expected = true }.go
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'calls the callback when the operation is successful' do
+        @expected = false
+        Defer.new{ true }.then{|result| @expected = true }.go
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'passes the result of the block to the callback' do
+        @expected = false
+        Defer.new{ 'w00t' }.then{|result| @expected = result }.go
+        sleep(0.1)
+        @expected.should eq 'w00t'
+      end
+
+      it 'does not call the errorback when the operation is successful' do
+        @expected = true
+        Defer.new{ nil }.rescue{|ex| @expected = false }.go
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'calls the errorback if the operation throws an exception' do
+        @expected = false
+        Defer.new{ raise StandardError }.rescue{|ex| @expected = true }.go
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'passes the exception object to the errorback' do
+        @expected = nil
+        Defer.new{ raise StandardError }.rescue{|ex| @expected = ex }.go
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'does not call the callback when the operation fails' do
+        @expected = true
+        Defer.new{ raise StandardError }.then{|result| @expected = false }.go
+        sleep(0.1)
+        @expected.should be_true
+      end
+    end
+  end
+end

data/spec/concurrent/event_machine_defer_proxy_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+require 'concurrent/agent'
+require 'concurrent/future'
+require 'concurrent/promise'
+
+module Concurrent
+
+  describe EventMachineDeferProxy do
+
+    subject { EventMachineDeferProxy.new }
+
+    context '#post' do
+
+      it 'proxies a call without arguments' do
+        @expected = false
+        EventMachine.run do
+          subject.post{ @expected = true }
+          sleep(0.1)
+          EventMachine.stop
+        end
+        @expected.should eq true
+      end
+
+      it 'proxies a call with arguments' do
+        @expected = []
+        EventMachine.run do
+          subject.post(1,2,3){|*args| @expected = args }
+          sleep(0.1)
+          EventMachine.stop
+        end
+        @expected.should eq [1,2,3]
+      end
+
+      it 'aliases #<<' do
+        @expected = false
+        EventMachine.run do
+          subject << proc{ @expected = true }
+          sleep(0.1)
+          EventMachine.stop
+        end
+        @expected.should eq true
+      end
+    end
+
+    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) }
+
+        it 'supports fulfillment' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = []
+            subject.post{ @expected << 1 }
+            subject.post{ @expected << 2 }
+            subject.post{ @expected << 3 }
+            sleep(0.1)
+            @expected.should eq [1,2,3]
+
+            EventMachine.stop
+          end
+        end
+
+        it 'supports validation' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = nil
+            subject.validate{ @expected = 10; true }
+            subject.post{ nil }
+            sleep(0.1)
+            @expected.should eq 10
+
+            EventMachine.stop
+          end
+        end
+
+        it 'supports rejection' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run do
+
+            @expected = nil
+            subject.
+              on_error(StandardError){|ex| @expected = 1 }.
+              on_error(StandardError){|ex| @expected = 2 }.
+              on_error(StandardError){|ex| @expected = 3 }
+            subject.post{ raise StandardError }
+            sleep(0.1)
+            @expected.should eq 1
+
+            EventMachine.stop
+          end
+        end
+      end
+
+      context Future do
+
+        it 'supports fulfillment' do
+          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+          EventMachine.run 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]
+
+            sleep(0.1)
+            EventMachine.stop
+          end
+        end
+      end
+
+      context Promise do
+
+        context 'fulfillment' do
+
+          it 'passes all arguments to the first promise in the chain' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run 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]
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'passes the result of each block to all its children' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+              @expected = nil
+              Promise.new(10){|a| a * 2 }.then{|result| @expected = result}
+              sleep(0.1)
+              @expected.should eq 20
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'sets the promise value to the result if its block' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
+              sleep(0.1)
+              p.value.should eq 40
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+        end
+
+        context 'rejection' do
+
+          it 'sets the promise reason and error on exception' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              p = Promise.new{ raise StandardError.new('Boom!') }
+              sleep(0.1)
+              p.reason.should be_a(Exception)
+              p.reason.should.to_s =~ /Boom!/
+              p.should be_rejected
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'calls the first exception block with a matching class' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              @expected = nil
+              Promise.new{ raise StandardError }.
+                on_error(StandardError){|ex| @expected = 1 }.
+                on_error(StandardError){|ex| @expected = 2 }.
+                on_error(StandardError){|ex| @expected = 3 }
+              sleep(0.1)
+              @expected.should eq 1
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+
+          it 'passes the exception object to the matched block' do
+            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
+
+            EventMachine.run do
+
+              @expected = nil
+              Promise.new{ raise StandardError }.
+                on_error(ArgumentError){|ex| @expected = ex }.
+                on_error(LoadError){|ex| @expected = ex }.
+                on_error(Exception){|ex| @expected = ex }
+              sleep(0.1)
+              @expected.should be_a(StandardError)
+
+              sleep(0.1)
+              EventMachine.stop
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/event_spec.rb

@@ -0,0 +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