concurrent-ruby 0.1.1 → 0.2.0

data/spec/concurrent/event_machine_defer_proxy_spec.rb

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

data/spec/concurrent/executor_spec.rb

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