concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/spec/concurrent/functions_spec.rb

@@ -167,26 +167,6 @@ module Concurrent
     end
   end
 
-  describe Defer do
-
-    before(:each) do
-      Defer.thread_pool = FixedThreadPool.new(1)
-    end
-
-    it 'aliases Kernel#defer' do
-      defer{ nil }.should be_a(Defer)
-    end
-  end
-
-  describe Executor do
-
-    it 'aliases Kernel#executor' do
-      ex = executor('executor'){ nil }
-      ex.should be_a(Executor::ExecutionContext)
-      ex.kill
-    end
-  end
-
   describe Future do
 
     before(:each) do

data/spec/concurrent/future_spec.rb

@@ -108,5 +108,93 @@ module Concurrent
         end
       end
     end
+
+    context 'observation' do
+
+      let(:clazz) do
+        Class.new do
+          attr_reader :value
+          attr_reader :reason
+          attr_reader :count
+          define_method(:update) do |time, value, reason|
+            @count = @count.to_i + 1
+            @value = value
+            @reason = reason
+          end
+        end
+      end
+
+      let(:observer) { clazz.new }
+
+      it 'notifies all observers on fulfillment' do
+        future = Future.new{ sleep(0.1); 42 }
+        future.add_observer(observer)
+        future.value.should == 42
+        future.reason.should be_nil
+        sleep(0.1)
+        observer.value.should == 42
+        observer.reason.should be_nil
+      end
+
+      it 'notifies all observers on rejection' do
+        future = Future.new{ sleep(0.1); raise StandardError }
+        future.add_observer(observer)
+        future.value.should be_nil
+        future.reason.should be_a(StandardError)
+        sleep(0.1)
+        observer.value.should be_nil
+        observer.reason.should be_a(StandardError)
+      end
+
+      it 'notifies an observer added after fulfillment' do
+        future = Future.new{ 42 }
+        sleep(0.1)
+        future.value.should == 42
+        future.add_observer(observer)
+        observer.value.should be_nil
+        sleep(0.1)
+        observer.value.should == 42
+      end
+
+      it 'notifies an observer added after rejection' do
+        future = Future.new{ raise StandardError }
+        sleep(0.1)
+        future.reason.should be_a(StandardError)
+        future.add_observer(observer)
+        observer.value.should be_nil
+        sleep(0.1)
+        observer.reason.should be_a(StandardError)
+      end
+
+      it 'does not notify existing observers when a new observer added after fulfillment' do
+        future = Future.new{ 42 }
+        future.add_observer(observer)
+        sleep(0.1)
+        future.value.should == 42
+        observer.count.should == 1
+
+        o2 = clazz.new
+        future.add_observer(o2)
+        sleep(0.1)
+
+        observer.count.should == 1
+        o2.value.should == 42
+      end
+
+      it 'does not notify existing observers when a new observer added after rejection' do
+        future = Future.new{ raise StandardError }
+        future.add_observer(observer)
+        sleep(0.1)
+        future.reason.should be_a(StandardError)
+        observer.count.should == 1
+
+        o2 = clazz.new
+        future.add_observer(o2)
+        sleep(0.1)
+
+        observer.count.should == 1
+        o2.reason.should be_a(StandardError)
+      end
+    end
   end
 end

data/spec/concurrent/null_thread_pool_spec.rb

@@ -14,20 +14,41 @@ module Concurrent
 
     context '#post' do
 
-      it 'proxies a call without arguments' do
+      it 'creates a new thread for a call without arguments' do
         thread = Thread.new{ nil }
         Thread.should_receive(:new).with(no_args()).and_return(thread)
         $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
         subject.post{ nil }
       end
 
-      it 'proxies a call with arguments' do
+      it 'executes a call without arguments' do
+        @expected = false
+        subject.post{ @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'creates a new thread for a call with arguments' do
         thread = Thread.new{ nil }
         Thread.should_receive(:new).with(1,2,3).and_return(thread)
         $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
         subject.post(1,2,3){ nil }
       end
 
+      it 'executes a call with one argument' do
+        @expected = 0
+        subject.post(1){|one| @expected = one }
+        sleep(0.1)
+        @expected.should == 1
+      end
+
+      it 'executes a call with multiple arguments' do
+        @expected = nil
+        subject.post(1,2,3,4,5){|*args| @expected = args }
+        sleep(0.1)
+        @expected.should eq [1,2,3,4,5]
+      end
+
       it 'aliases #<<' do
         thread = Thread.new{ nil }
         Thread.should_receive(:new).with(no_args()).and_return(thread)

data/spec/concurrent/obligation_shared.rb

@@ -27,14 +27,12 @@ share_examples_for Concurrent::Obligation do
 
     it 'blocks the caller when :pending and timeout is nil' do
       f = pending_subject
-      sleep(0.1)
       f.value.should be_true
       f.should be_fulfilled
     end
 
     it 'returns nil when reaching the optional timeout value' do
       f = pending_subject
-      sleep(0.1)
       f.value(0).should be_nil
       f.should be_pending
     end
@@ -42,21 +40,18 @@ share_examples_for Concurrent::Obligation do
     it 'returns immediately when timeout is zero' do
       Timeout.should_not_receive(:timeout).with(any_args())
       f = pending_subject
-      sleep(0.1)
       f.value(0).should be_nil
       f.should be_pending
     end
 
     it 'returns the value when fulfilled before timeout' do
       f = pending_subject
-      sleep(0.1)
       f.value(10).should be_true
       f.should be_fulfilled
     end
 
     it 'returns nil when timeout reached' do
       f = pending_subject
-      sleep(0.1)
       f.value(0.1).should be_nil
       f.should be_pending
     end

data/spec/concurrent/promise_spec.rb

@@ -156,7 +156,7 @@ module Concurrent
       it 'sets the promise reason the error object on exception' do
         p = Promise.new{ raise StandardError.new('Boom!') }
         sleep(0.1)
-        p.reason.should be_a(Exception)
+        p.reason.should be_a(StandardError)
         p.reason.should.to_s =~ /Boom!/
       end
 
@@ -207,7 +207,7 @@ module Concurrent
         Promise.new{ raise ArgumentError }.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
+          rescue(StandardError){|ex| @expected = 3 }
         sleep(0.1)
         @expected.should eq 1
 
@@ -215,7 +215,7 @@ module Concurrent
         Promise.new{ raise LoadError }.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
+          rescue(StandardError){|ex| @expected = 3 }
         sleep(0.1)
         @expected.should eq 2
 
@@ -223,7 +223,7 @@ module Concurrent
         Promise.new{ raise StandardError }.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
+          rescue(StandardError){|ex| @expected = 3 }
         sleep(0.1)
         @expected.should eq 3
       end
@@ -233,7 +233,7 @@ module Concurrent
         Promise.new{ raise StandardError }.
           rescue(ArgumentError){|ex| @expected = ex }.
           rescue(LoadError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
+          rescue(StandardError){|ex| @expected = ex }
         sleep(0.1)
         @expected.should be_a(StandardError)
       end
@@ -242,8 +242,7 @@ module Concurrent
         @expected = nil
         Promise.new{ raise StandardError }.
           rescue(StandardError).
-          rescue(StandardError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
+          rescue(StandardError){|ex| @expected = ex }
         sleep(0.1)
         @expected.should be_a(StandardError)
       end
@@ -252,8 +251,8 @@ module Concurrent
         lambda {
           Promise.new{ raise StandardError }.
             rescue(ArgumentError){|ex| @expected = ex }.
-            rescue(StandardError){|ex| @expected = ex }.
-            rescue(Exception){|ex| @expected = ex }
+            rescue(NotImplementedError){|ex| @expected = ex }.
+            rescue(NoMethodError){|ex| @expected = ex }
           sleep(0.1)
         }.should_not raise_error
       end
@@ -261,7 +260,7 @@ module Concurrent
       it 'supresses exceptions thrown from rescue handlers' do
         lambda {
           Promise.new{ raise ArgumentError }.
-          rescue(Exception){ raise StandardError }
+          rescue(StandardError){ raise StandardError }
           sleep(0.1)
         }.should_not raise_error
       end

data/spec/concurrent/runnable_shared.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+share_examples_for :runnable do
+
+  after(:each) do
+    subject.stop
+    @thread.kill unless @thread.nil?
+    sleep(0.1)
+  end
+
+  context '#run' do
+
+    it 'starts the (blocking) runner on the current thread when stopped' do
+      @thread = Thread.new { subject.run }
+      @thread.join(1).should be_nil
+    end
+
+    it 'raises an exception when already running' do
+      @thread = Thread.new { subject.run }
+      @thread.join(0.1)
+      expect {
+        subject.run
+      }.to raise_error
+    end
+
+    it 'returns true when stopped normally' do
+      @expected = false
+      @thread = Thread.new { @expected = subject.run }
+      @thread.join(0.1)
+      subject.stop
+      @thread.join(1)
+      @expected.should be_true
+    end
+  end
+
+  context '#stop' do
+
+    it 'returns true when not running' do
+      subject.stop.should be_true
+    end
+
+    it 'returns true when successfully stopped' do
+      @thread = Thread.new { subject.run }
+      @thread.join(0.1)
+      subject.stop.should be_true
+      subject.should_not be_running
+    end
+  end
+
+  context '#running?' do
+
+    it 'returns true when running' do
+      @thread = Thread.new { subject.run }
+      @thread.join(0.1)
+      subject.should be_running
+    end
+
+    it 'returns false when not running' do
+      subject.should_not be_running
+    end
+  end
+end

data/spec/concurrent/runnable_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+require_relative 'runnable_shared'
+
+module Concurrent
+
+  describe Runnable do
+
+    let(:runnable) do
+      Class.new {
+        include Runnable
+        attr_reader :thread
+        def initialize(*args, &block)
+          yield if block_given?
+        end
+        def on_task
+          @thread = Thread.current
+          sleep(0.1)
+        end
+        def on_run() return true; end
+        def after_run() return true; end
+        def on_stop() return true; end
+      }
+    end
+
+    subject { runnable.new }
+
+    it_should_behave_like :runnable
+
+    after(:each) do
+      subject.stop
+      @thread.kill unless @thread.nil?
+      sleep(0.1)
+    end
+
+    context '#run' do
+
+      it 'calls #on_run when implemented' do
+        subject.should_receive(:on_run).with(no_args())
+        @thread = Thread.new { subject.run }
+        sleep(0.1)
+      end
+
+      it 'does not attempt to call #on_run when not implemented' do
+        subject.class.send(:remove_method, :on_run)
+        @thread = Thread.new do
+          expect {
+            subject.run
+          }.not_to raise_error
+        end
+        sleep(0.1)
+      end
+
+      it 'return false when #on_run raises an exception' do
+        @expected = true
+        subject.stub(:on_run).and_raise(StandardError)
+        @thread = Thread.new do
+          @expected = subject.run
+        end
+        sleep(0.1)
+        @expected.should be_false
+      end
+
+      it 'calls #on_task in an infinite loop' do
+        subject.should_receive(:on_task).with(no_args()).at_least(1)
+        @thread = Thread.new { subject.run }
+        @thread.join(1)
+      end
+
+      it 'raises an exception if the #on_task callback is not implemented' do
+        runner = Class.new { include Runnable }.new
+        expect {
+          runner.run
+        }.to raise_error(Runnable::LifecycleError)
+      end
+
+      it 'returns false when the task loop raises an exception' do
+        @expected = false
+        subject.stub(:on_task).and_raise(StandardError)
+        @thread = Thread.new { @expected = subject.run }
+        @thread.join(0.1)
+        @expected.should be_false
+      end
+    end
+
+    context '#stop' do
+
+      it 'calls #on_stop when implemented' do
+        subject.should_receive(:on_stop).with(no_args())
+        @thread = Thread.new { subject.run }
+        sleep(0.1)
+        subject.stop
+        sleep(0.1)
+      end
+
+      it 'does not attempt to call #on_stop when not implemented' do
+        subject.class.send(:remove_method, :on_stop)
+        @thread = Thread.new { subject.run }
+        sleep(0.1)
+        expect {
+          subject.stop
+          sleep(0.1)
+        }.not_to raise_error
+      end
+
+      it 'return false when #on_stop raises an exception' do
+        subject.stub(:on_stop).and_raise(StandardError)
+        @thread = Thread.new { subject.run }
+        sleep(0.1)
+        subject.stop.should be_false
+        subject.should_not be_running
+      end
+
+      it 'calls #after_run when implemented' do
+        subject.should_receive(:after_run).with(no_args())
+        @thread = Thread.new { subject.run }
+        sleep(0.1)
+        subject.stop
+        sleep(0.2)
+      end
+
+      it 'does not attempt to call #after_run when not implemented' do
+        subject.class.send(:remove_method, :after_run)
+        @thread = Thread.new { subject.run }
+        sleep(0.1)
+        expect {
+          subject.stop
+          sleep(0.2)
+        }.not_to raise_error
+      end
+    end
+
+    context '#running?' do
+
+      it 'returns false if runner abends' do
+        subject.stub(:on_task).and_raise(StandardError)
+        @thread = Thread.new { subject.run }
+        @thread.join(0.1)
+        subject.should_not be_running
+      end
+    end
+
+    context 'instance #run!' do
+
+      let(:clazz) do
+        Class.new { include Runnable }
+      end
+
+      subject { clazz.new }
+
+      after(:each) do
+        @context.runner.stop if @context && @context.runner
+        @context.thread.kill if @context && @context.thread
+      end
+
+      it 'creates a new thread' do
+        Thread.should_receive(:new).with(any_args()).and_return(nil)
+        @context = subject.run!
+        sleep(0.1)
+      end
+
+      it 'runs the runner on the new thread' do
+        @context = subject.run!
+        sleep(0.1)
+        @context.thread.should_not eq Thread.current
+      end
+
+      it 'returns a context object on success' do
+        @context = subject.run!
+        sleep(0.1)
+        @context.should be_a(Running::Context)
+      end
+    end
+
+    context 'module #run!' do
+
+      let(:clazz) do
+        Class.new { include Runnable }
+      end
+
+      after(:each) do
+        @context.runner.stop if @context && @context.runner
+        @context.thread.kill if @context && @context.thread
+      end
+
+      it 'creates a new runner' do
+        clazz.should_receive(:new).once.with(no_args())
+        @context = clazz.run!
+        sleep(0.1)
+      end
+
+      it 'passes all args to the runner constructor' do
+        args = [1, 2, :three, :four]
+        clazz.should_receive(:new).once.with(*args)
+        @context = clazz.run!(*args)
+        sleep(0.1)
+      end
+
+      it 'passes a block argument to the runner constructor' do
+        @expected = false
+        @context = runnable.run!{ @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+
+      it 'creates a new thread' do
+        Thread.should_receive(:new).with(any_args()).and_return(nil)
+        @context = runnable.run!
+        sleep(0.1)
+      end
+
+      it 'runs the runner on the new thread' do
+        @context = runnable.run!
+        sleep(0.1)
+        @context.runner.thread.should_not eq Thread.current
+        @context.runner.thread.should eq @context.thread
+        @context.thread.should_not eq Thread.current
+      end
+
+      it 'returns a context object on success' do
+        @context = runnable.run!
+        sleep(0.1)
+        @context.should be_a(Running::Context)
+      end
+
+      it 'returns nil on failure' do
+        Thread.stub(:new).with(any_args()).and_raise(StandardError)
+        @context = runnable.run!
+        sleep(0.1)
+        @context.should be_nil
+      end
+    end
+  end
+end