concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/spec/concurrent/safe_task_executor_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'concurrent/safe_task_executor'
+
+module Concurrent
+
+  describe SafeTaskExecutor do
+
+    describe '#execute' do
+
+      context 'happy execution' do
+
+        let(:task) { Proc.new { 42 } }
+        let(:executor) { SafeTaskExecutor.new(task) }
+
+        it 'should return success' do
+          success, value, reason = executor.execute
+          success.should be_true
+        end
+
+        it 'should return task value' do
+          success, value, reason = executor.execute
+          value.should eq 42
+        end
+
+        it 'should return a nil reason' do
+          success, value, reason = executor.execute
+          reason.should be_nil
+        end
+
+      end
+
+      context 'failing execution' do
+
+        let(:task) { Proc.new { raise StandardError.new('an error') } }
+        let(:executor) { SafeTaskExecutor.new(task) }
+
+        it 'should return false success' do
+          success, value, reason = executor.execute
+          success.should be_false
+        end
+
+        it 'should return a nil value' do
+          success, value, reason = executor.execute
+          value.should be_nil
+        end
+
+        it 'should return the reason' do
+          success, value, reason = executor.execute
+          reason.should be_a(StandardError)
+          reason.message.should eq 'an error'
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/concurrent/scheduled_task_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'timecop'
+require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
 
 module Concurrent
@@ -14,77 +15,183 @@ module Concurrent
       let!(:rejected_reason) { StandardError.new('mojo jojo') }
 
       let(:pending_subject) do
-        ScheduledTask.new(1){ fulfilled_value }
+        ScheduledTask.new(1){ fulfilled_value }.execute
       end
 
       let(:fulfilled_subject) do
-        ScheduledTask.new(0.1){ fulfilled_value }.tap(){ sleep(0.2) }
+        ScheduledTask.new(0.1){ fulfilled_value }.execute.tap{ sleep(0.2) }
       end
 
       let(:rejected_subject) do
-        ScheduledTask.new(0.1){ raise rejected_reason }.tap(){ sleep(0.2) }
+        ScheduledTask.new(0.1){ raise rejected_reason }.execute.tap{ sleep(0.2) }
       end
 
       it_should_behave_like :obligation
+
+      # dereferenceable
+
+      def dereferenceable_subject(value, opts = {})
+        ScheduledTask.execute(0.1, opts){ value }.tap{ sleep(0.2) }
+      end
+
+      def dereferenceable_observable(opts = {})
+        ScheduledTask.new(0.1, opts){ 'value' }
+      end
+
+      def execute_dereferenceable(subject)
+        subject.execute
+        sleep(0.2)
+      end
+
+      it_should_behave_like :dereferenceable
     end
 
     context '#initialize' do
 
-      it 'accepts a number of seconds (from now) as the shcedule time' do
+      it 'accepts a number of seconds (from now) as the schedule time' do
         Timecop.freeze do
           now = Time.now
-          task = ScheduledTask.new(60){ nil }
+          task = ScheduledTask.new(60){ nil }.execute
           task.schedule_time.to_i.should eq now.to_i + 60
         end
       end
 
       it 'accepts a time object as the schedule time' do
         schedule = Time.now + (60*10)
-        task = ScheduledTask.new(schedule){ nil }
+        task = ScheduledTask.new(schedule){ nil }.execute
         task.schedule_time.should eq schedule
       end
 
       it 'raises an exception when seconds is less than zero' do
         expect {
           ScheduledTask.new(-1){ nil }
-        }.to raise_error(ArgumentError)
+        }.to raise_error(ScheduledTask::SchedulingError)
       end
 
       it 'raises an exception when schedule time is in the past' do
         expect {
           ScheduledTask.new(Time.now - 60){ nil }
-        }.to raise_error(ArgumentError)
+        }.to raise_error(ScheduledTask::SchedulingError)
       end
 
       it 'raises an exception when no block given' do
         expect {
           ScheduledTask.new(1)
-        }.to raise_error(ArgumentError)
+        }.to raise_error(ScheduledTask::SchedulingError)
+      end
+
+      it 'sets the initial state to :unscheduled' do
+        task = ScheduledTask.new(1){ nil }
+        task.should be_unscheduled
+      end
+
+      it 'sets the #schedule_time to nil prior to execution' do
+        task = ScheduledTask.new(1){ nil }
+        task.schedule_time.should be_nil
+      end
+    end
+
+    context 'instance #execute' do
+
+      it 'does nothing unless the state is :unscheduled' do
+        Thread.should_not_receive(:new).with(any_args)
+        task = ScheduledTask.new(1){ nil }
+        task.instance_variable_set(:@state, :pending)
+        task.execute
+        task.instance_variable_set(:@state, :rejected)
+        task.execute
+        task.instance_variable_set(:@state, :fulfilled)
+        task.execute
+      end
+
+      it 'calculates the #schedule_time on execution' do
+        Timecop.freeze do
+          now = Time.now
+          task = ScheduledTask.new(5){ nil }
+          Timecop.travel(10)
+          task.execute
+          task.schedule_time.to_i.should eq now.to_i + 15
+        end
+      end
+
+      it 'raises an exception if expected schedule time is in the past' do
+        Timecop.freeze do
+          schedule = Time.now + (10)
+          task = ScheduledTask.new(schedule){ nil }
+          Timecop.travel(60)
+          expect {
+            task.execute
+          }.to raise_error(ScheduledTask::SchedulingError)
+        end
+      end
+
+      it 'spawns a new thread when a block was given on construction' do
+        Thread.should_receive(:new).with(any_args)
+        task = ScheduledTask.new(1){ nil }
+        task.execute
       end
 
-      it 'sets the initial state to :pending' do
+      it 'sets the sate to :pending' do
         task = ScheduledTask.new(1){ nil }
+        task.execute
         task.should be_pending
       end
+
+      it 'returns self' do
+        task = ScheduledTask.new(1){ nil }
+        task.execute.should eq task
+      end
+    end
+
+    context 'class #execute' do
+
+      it 'creates a new ScheduledTask' do
+        task = ScheduledTask.execute(1){ nil }
+        task.should be_a(ScheduledTask)
+      end
+
+      it 'passes the block to the new ScheduledTask' do
+        @expected = false
+        task = ScheduledTask.execute(0.1){ @expected = true }
+        sleep(0.2)
+        @expected.should be_true
+      end
+
+      it 'calls #execute on the new ScheduledTask' do
+        task = ScheduledTask.new(0.1){ nil }
+        ScheduledTask.stub(:new).with(any_args).and_return(task)
+        task.should_receive(:execute).with(no_args)
+        ScheduledTask.execute(0.1){ nil }
+      end
     end
 
     context '#cancel' do
 
       it 'returns false if the task has already been performed' do
-        task = ScheduledTask.new(0.1){ 42 }
+        task = ScheduledTask.new(0.1){ 42 }.execute
         sleep(0.2)
         task.cancel.should be_false
       end
 
       it 'returns false if the task is already in progress' do
-        task = ScheduledTask.new(0.1){ sleep(1); 42 }
+        task = ScheduledTask.new(0.1){ sleep(1); 42 }.execute
         sleep(0.2)
         task.cancel.should be_false
       end
 
+      it 'cancels the task if it has not yet scheduled' do
+        @expected = true
+        task = ScheduledTask.new(0.1){ @expected = false }
+        task.cancel
+        task.execute
+        sleep(0.5)
+        @expected.should be_true
+      end
+
+
       it 'cancels the task if it has not yet started' do
         @expected = true
-        task = ScheduledTask.new(0.3){ @expected = false }
+        task = ScheduledTask.new(0.3){ @expected = false }.execute
         sleep(0.1)
         task.cancel
         sleep(0.5)
@@ -92,13 +199,13 @@ module Concurrent
       end
 
       it 'returns true on success' do
-        task = ScheduledTask.new(0.3){ @expected = false }
+        task = ScheduledTask.new(0.3){ @expected = false }.execute
         sleep(0.1)
         task.cancel.should be_true
       end
 
       it 'sets the state to :cancelled when cancelled' do
-        task = ScheduledTask.new(10){ 42 }
+        task = ScheduledTask.new(10){ 42 }.execute
         sleep(0.1)
         task.cancel
         task.should be_cancelled
@@ -108,7 +215,7 @@ module Concurrent
     context 'execution' do
 
       it 'sets the state to :in_progress when the task is running' do
-        task = ScheduledTask.new(0.1){ sleep(1); 42 }
+        task = ScheduledTask.new(0.1){ sleep(1); 42 }.execute
         sleep(0.2)
         task.should be_in_progress
       end
@@ -131,44 +238,42 @@ module Concurrent
 
       let(:observer) { clazz.new }
 
-      it 'returns true for an observer added while :pending' do
-        task = ScheduledTask.new(1){ 42 }
+      it 'returns true for an observer added while :unscheduled' do
+        task = ScheduledTask.new(0.1){ 42 }
         task.add_observer(observer).should be_true
       end
 
-      it 'returns true for an observer added while :in_progress' do
-        task = ScheduledTask.new(0.1){ sleep(1); 42 }
-        sleep(0.2)
+      it 'returns true for an observer added while :pending' do
+        task = ScheduledTask.new(0.1){ 42 }.execute
         task.add_observer(observer).should be_true
       end
 
-      it 'returns true for an observer added while not running' do
-        task = ScheduledTask.new(1){ 42 }
+      it 'returns true for an observer added while :in_progress' do
+        task = ScheduledTask.new(0.1){ sleep(1); 42 }.execute
+        sleep(0.2)
         task.add_observer(observer).should be_true
       end
 
       it 'returns false for an observer added once :cancelled' do
         task = ScheduledTask.new(1){ 42 }
-        sleep(0.1)
         task.cancel
-        sleep(0.1)
         task.add_observer(observer).should be_false
       end
 
       it 'returns false for an observer added once :fulfilled' do
-        task = ScheduledTask.new(0.1){ 42 }
+        task = ScheduledTask.new(0.1){ 42 }.execute
         sleep(0.2)
         task.add_observer(observer).should be_false
       end
 
       it 'returns false for an observer added once :rejected' do
-        task = ScheduledTask.new(0.1){ raise StandardError }
+        task = ScheduledTask.new(0.1){ raise StandardError }.execute
         sleep(0.2)
         task.add_observer(observer).should be_false
       end
 
       it 'notifies all observers on fulfillment' do
-        task = ScheduledTask.new(0.1){ 42 }
+        task = ScheduledTask.new(0.1){ 42 }.execute
         task.add_observer(observer)
         sleep(0.2)
         task.value.should == 42
@@ -178,7 +283,7 @@ module Concurrent
       end
 
       it 'notifies all observers on rejection' do
-        task = ScheduledTask.new(0.1){ raise StandardError }
+        task = ScheduledTask.new(0.1){ raise StandardError }.execute
         task.add_observer(observer)
         sleep(0.2)
         task.value.should be_nil
@@ -188,30 +293,29 @@ module Concurrent
       end
 
       it 'does not notify an observer added after fulfillment' do
-        observer.should_not_receive(:update).with(any_args())
-        task = ScheduledTask.new(0.1){ 42 }
+        observer.should_not_receive(:update).with(any_args)
+        task = ScheduledTask.new(0.1){ 42 }.execute
         sleep(0.2)
         task.add_observer(observer)
         sleep(0.1)
       end
 
       it 'does not notify an observer added after rejection' do
-        observer.should_not_receive(:update).with(any_args())
-        task = ScheduledTask.new(0.1){ raise StandardError }
+        observer.should_not_receive(:update).with(any_args)
+        task = ScheduledTask.new(0.1){ raise StandardError }.execute
         sleep(0.2)
         task.add_observer(observer)
         sleep(0.1)
       end
 
       it 'does not notify an observer added after cancellation' do
-        observer.should_not_receive(:update).with(any_args())
-        task = ScheduledTask.new(0.5){ 42 }
-        sleep(0.1)
+        observer.should_not_receive(:update).with(any_args)
+        task = ScheduledTask.new(0.1){ 42 }.execute
         task.cancel
-        sleep(0.1)
         task.add_observer(observer)
-        sleep(0.5)
+        sleep(0.2)
       end
+
     end
   end
 end

data/spec/concurrent/thread_local_var_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'rbconfig'
+
+module Concurrent
+
+  describe ThreadLocalVar do
+
+    subject{ ThreadLocalVar.new }
+
+    context '#initialize' do
+
+      it 'can set an initial value' do
+        v = ThreadLocalVar.new(14)
+        v.value.should eq 14
+      end
+
+      it 'sets nil as a default initial value' do
+        v = ThreadLocalVar.new
+        v.value.should be_nil
+      end
+
+      it 'sets the same initial value for all threads' do
+        v = ThreadLocalVar.new(14)
+        t1 = Thread.new { v.value }
+        t2 = Thread.new { v.value }
+        t1.value.should eq 14
+        t2.value.should eq 14
+      end
+
+      if jruby?
+        it 'uses ThreadLocalJavaStorage' do
+          subject.class.ancestors.should include(Concurrent::ThreadLocalJavaStorage)
+        end
+      elsif rbx? || RbConfig::CONFIG['ruby_version'] =~ /^1\.9/
+        it 'uses ThreadLocalOldStorage' do
+          subject.class.ancestors.should include(Concurrent::ThreadLocalOldStorage)
+        end
+      else
+        it 'uses ThreadLocalNewStorage' do
+          subject.class.ancestors.should include(Concurrent::ThreadLocalNewStorage)
+        end
+      end
+    end
+
+    context '#value' do
+
+      it 'returns the current value' do
+        v = ThreadLocalVar.new(14)
+        v.value.should eq 14
+      end
+
+      it 'returns the value after modification' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+        v.value.should eq 2
+      end
+
+    end
+
+    context '#value=' do
+
+      it 'sets a new value' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+        v.value.should eq 2
+      end
+
+      it 'returns the new value' do
+        v = ThreadLocalVar.new(14)
+        (v.value = 2).should eq 2
+      end
+
+      it 'does not modify the initial value for other threads' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+        t = Thread.new { v.value }
+        t.value.should eq 14
+      end
+
+      it 'does not modify the value for other threads' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+
+        b1 = CountDownLatch.new(2)
+        b2 = CountDownLatch.new(2)
+
+        t1 = Thread.new do
+          b1.count_down
+          b1.wait
+          v.value = 1
+          b2.count_down
+          b2.wait
+          v.value
+        end
+
+        t2 = Thread.new do
+          b1.count_down
+          b1.wait
+          v.value = 2
+          b2.count_down
+          b2.wait
+          v.value
+        end
+
+        t1.value.should eq 1
+        t2.value.should eq 2
+      end
+
+    end
+
+  end
+
+end