concurrent-ruby 0.1.1.pre.5 → 0.1.1

data/spec/concurrent/cached_thread_pool_spec.rb

@@ -10,7 +10,6 @@ module Concurrent
     it_should_behave_like 'Thread Pool'
 
     context '#initialize' do
-
       it 'aliases Concurrent#new_cached_thread_pool' do
         pool = Concurrent.new_cached_thread_pool
         pool.should be_a(CachedThreadPool)
@@ -21,7 +20,7 @@ module Concurrent
     context '#kill' do
 
       it 'kills all threads' do
-        Thread.should_receive(:kill).at_least(5).times
+        Thread.should_receive(:kill).exactly(5).times
         pool = CachedThreadPool.new
         5.times{ sleep(0.1); pool << proc{ sleep(1) } }
         sleep(1)
@@ -109,17 +108,5 @@ module Concurrent
         subject.instance_variable_get(:@collector).status.should be_false
       end
     end
-
-    context '#status' do
-
-      it 'returns an empty collection when the pool is empty' do
-        subject.status.should be_empty
-      end
-
-      it 'returns one status object for each thread in the pool' do
-        3.times{ sleep(0.1); subject << proc{ sleep(0.5) } }
-        subject.status.length.should eq 3
-      end
-    end
   end
 end

data/spec/concurrent/defer_spec.rb

@@ -4,12 +4,12 @@ module Concurrent
 
   describe Defer do
 
-    before(:each) do
-      Defer.thread_pool = FixedThreadPool.new(1)
-    end
-
     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
@@ -19,19 +19,23 @@ module Concurrent
       it 'raises an exception if both a block and an operation given' do
         lambda {
           operation = proc{ nil }
-          Defer.new(op: operation){ nil }
+          Defer.new(operation, nil, nil){ nil }
         }.should raise_error(ArgumentError)
       end
 
       it 'starts the thread if an operation is given' do
-        Defer.thread_pool.should_receive(:post).once.with(any_args())
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
         operation = proc{ nil }
-        Defer.new(op: operation)
+        Defer.new(operation, nil, nil)
       end
 
       it 'does not start the thread if neither a callback or errorback is given' do
-        Defer.thread_pool.should_not_receive(:post)
-        Defer.new{ nil }
+        $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
 
@@ -52,14 +56,14 @@ module Concurrent
       it 'raises an exception if an operation was provided at construction' do
         lambda {
           operation = proc{ nil }
-          Defer.new(op: operation).then{|result| 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(callback: callback){ nil }.then{|result| nil }
+          Defer.new(nil, callback, nil){ nil }.then{|result| nil }
         }.should raise_error(IllegalMethodCallError)
       end
 
@@ -86,14 +90,14 @@ module Concurrent
       it 'raises an exception if an operation was provided at construction' do
         lambda {
           operation = proc{ nil }
-          Defer.new(op: operation).rescue{|ex| 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(errorback: errorback){ nil }.rescue{|ex| nil }
+          Defer.new(nil, nil, errorback){ nil }.rescue{|ex| nil }
         }.should raise_error(IllegalMethodCallError)
       end
 
@@ -119,14 +123,14 @@ module Concurrent
 
       it 'starts the thread if not started' do
         deferred = Defer.new{ nil }
-        Defer.thread_pool.should_receive(:post).once.with(any_args())
+        $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
-        Defer.thread_pool.should_not_receive(:post)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post)
         deferred.go
       end
 
@@ -134,8 +138,8 @@ module Concurrent
         operation = proc{ nil }
         callback = proc{|result| nil }
         errorback = proc{|ex| nil }
-        deferred = Defer.new(op: operation, callback: callback, errorback: errorback)
-        Defer.thread_pool.should_not_receive(:post)
+        deferred = Defer.new(operation, callback, errorback)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post)
         deferred.go
       end
     end

data/spec/concurrent/event_machine_defer_proxy_spec.rb

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