concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/spec/concurrent/future_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -54,6 +55,17 @@ module Concurrent
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+      
+      subject{ Future.new{ nil } }
+      
+      def trigger_observable(observable)
+        observable.execute
+        sleep(0.1)
+      end
+
+      it_should_behave_like :observable
     end
 
     context 'subclassing' do

data/spec/concurrent/ivar_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -56,10 +57,19 @@ module Concurrent
 
       def execute_dereferenceable(subject)
         subject.set('value')
-        sleep(0.1)
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+      
+      subject{ IVar.new }
+      
+      def trigger_observable(observable)
+        observable.set('value')
+      end
+
+      it_should_behave_like :observable
     end
 
     context '#initialize' do

data/spec/concurrent/observable_shared.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+share_examples_for :observable do
+
+  let(:observer_set) do
+    subject.instance_variable_get(:@observers)
+  end
+
+  let(:observer_class) do
+    Class.new do
+      def initialize(&block)
+        @block = block
+      end
+      def update(*args)
+        @block.call(*args) if @block
+      end
+    end
+  end
+
+  let(:observer){ observer_class.new }
+
+  let!(:observer_func){ :notify }
+
+  let(:observer_with_func_class) do
+    Class.new do
+      def initialize(&block)
+        @block = block
+      end
+      def notify(*args)
+        @block.call(*args) if @block
+      end
+    end
+  end
+
+  let(:observer_with_func){ observer_with_func_class.new }
+
+  context '#add_observer' do
+
+    it 'adds an observer if called before first notification' do
+      observer_set.should_receive(:add_observer).with(any_args)
+      subject.add_observer(observer)
+    end
+
+    it 'adds an observer with :func if called before first notification' do
+      observer_set.should_receive(:add_observer).with(observer_with_func, :notify)
+      subject.add_observer(observer_with_func, observer_func)
+    end
+
+    it 'creates an observer from a block if called before first notification' do
+      block = proc{ nil }
+      observer_set.should_receive(:add_observer).with(any_args)
+      subject.add_observer(&block)
+    end
+
+    it 'raises an exception if not given an observer or a block' do
+      expect {
+        subject.add_observer
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when given both an observer and a block' do
+      expect {
+        subject.add_observer(observer){ nil }
+      }.to raise_error(ArgumentError)
+    end
+  end
+  
+  context '#delete_observer' do
+  
+    it 'deletes the given observer if called before first notification' do
+      subject.count_observers.should eq 0
+      subject.add_observer(observer)
+      subject.count_observers.should eq 1
+      subject.delete_observer(observer)
+      subject.count_observers.should eq 0
+    end
+
+    it 'returns the removed observer if found in the observer set' do
+      subject.add_observer(observer)
+      subject.delete_observer(observer).should eq observer
+    end
+
+    it 'returns the given observer even when not found in the observer set' do
+      subject.delete_observer(observer).should eq observer
+    end
+  end
+  
+  context '#delete_observers' do
+
+    it 'deletes all observers when called before first notification' do
+      5.times{ subject.add_observer(observer_class.new) }
+      subject.count_observers.should eq 5
+      subject.delete_observers
+      subject.count_observers.should eq 0
+    end
+
+    it 'returns self' do
+      subject.delete_observers.should eq subject
+    end
+  end
+  
+  context '#count_observers' do
+  
+    it 'returns zero for a new observable object' do
+      subject.count_observers.should eq 0
+    end
+
+    it 'returns a count of registered observers if called before first notification' do
+      5.times{ subject.add_observer(observer_class.new) }
+      subject.count_observers.should eq 5
+    end
+
+    it 'returns zero after #delete_observers has been called' do
+      5.times{ subject.add_observer(observer_class.new) }
+      subject.delete_observers
+      subject.count_observers.should eq 0
+    end
+  end
+
+  context 'first notification' do
+
+    it 'calls the #update method on all observers without a specified :func' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        subject.add_observer(observer_class.new{ latch.count_down })
+      end
+      trigger_observable(subject)
+      latch.count.should eq 0
+    end
+
+    it 'calls the appropriate function on all observers which specified a :func' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        obs = observer_with_func_class.new{ latch.count_down }
+        subject.add_observer(obs, observer_func)
+      end
+      trigger_observable(subject)
+      latch.count.should eq 0
+    end
+
+    it 'calls the proc for all observers added as a block' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        subject.add_observer{ latch.count_down }
+      end
+      trigger_observable(subject)
+      latch.count.should eq 0
+    end
+
+    it 'does not notify any observers removed with #delete_observer' do
+      latch = Concurrent::CountDownLatch.new(5)
+      
+      obs = observer_class.new{ latch.count_down }
+      subject.add_observer(obs)
+      subject.delete_observer(obs)
+
+      trigger_observable(subject)
+      latch.count.should eq 5
+    end
+
+    it 'does not notify any observers after #delete_observers called' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        subject.add_observer(observer_class.new{ latch.count_down })
+      end
+
+      subject.delete_observers
+
+      trigger_observable(subject)
+      latch.count.should eq 5
+    end
+  end
+end

data/spec/concurrent/observable_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Observable do
+
+    let (:described_class) do
+      Class.new do
+        include Concurrent::Observable
+        public :observers, :observers=
+      end
+    end
+
+    let(:observer_set) { double(:observer_set) }
+    subject { described_class.new }
+
+    before(:each) do
+      subject.observers = observer_set
+    end
+
+    it 'does not initialize set by by default' do
+      described_class.new.observers.should be_nil
+    end
+
+    it 'uses the given observer set' do
+      expected = CopyOnWriteObserverSet.new
+      subject.observers = expected
+      subject.observers.should eql expected
+    end
+
+    it 'delegates #add_observer' do
+      observer_set.should_receive(:add_observer).with(:observer)
+      subject.add_observer(:observer)
+    end
+
+    it 'delegates #delete_observer' do
+      observer_set.should_receive(:delete_observer).with(:observer)
+      subject.delete_observer(:observer)
+    end
+
+    it 'delegates #delete_observers' do
+      observer_set.should_receive(:delete_observers).with(no_args)
+      subject.delete_observers
+    end
+
+    it 'delegates #count_observers' do
+      observer_set.should_receive(:count_observers).with(no_args)
+      subject.count_observers
+    end
+  end
+end

data/spec/concurrent/options_parser_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe OptionsParser do
+
+    let(:executor){ ImmediateExecutor.new }
+
+    let(:task_pool){ ImmediateExecutor.new }
+    let(:operation_pool){ ImmediateExecutor.new }
+
+    context '#get_executor_from' do
+
+      it 'returns the given :executor' do
+        OptionsParser::get_executor_from(executor: executor).should eq executor
+      end
+
+      it 'returns the global operation pool when :operation is true' do
+        Concurrent.configuration.should_receive(:global_operation_pool).
+          and_return(:operation_pool)
+        OptionsParser::get_executor_from(operation: true)
+      end
+
+      it 'returns the global task pool when :operation is false' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        OptionsParser::get_executor_from(operation: false)
+      end
+
+      it 'returns the global operation pool when :task is false' do
+        Concurrent.configuration.should_receive(:global_operation_pool).
+          and_return(:operation_pool)
+        OptionsParser::get_executor_from(task: false)
+      end
+
+      it 'returns the global task pool when :task is true' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        OptionsParser::get_executor_from(task: true)
+      end
+
+      it 'returns the global task pool when :executor is nil' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        OptionsParser::get_executor_from(executor: nil)
+      end
+
+      it 'returns the global task pool when no option is given' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        OptionsParser::get_executor_from
+      end
+
+      specify ':executor overrides :operation' do
+        OptionsParser::get_executor_from(executor: executor, operation: true).
+          should eq executor
+      end
+
+      specify ':executor overrides :task' do
+        OptionsParser::get_executor_from(executor: executor, task: true).
+          should eq executor
+      end
+
+      specify ':operation overrides :task' do
+        Concurrent.configuration.should_receive(:global_operation_pool).
+          and_return(:operation_pool)
+        OptionsParser::get_executor_from(operation: true, task: true)
+      end
+    end
+  end
+end

data/spec/concurrent/runnable_shared.rb

@@ -55,7 +55,13 @@ share_examples_for :runnable do
       subject.should be_running
     end
 
+    it 'returns false when first created' do
+      subject.should_not be_running
+    end
+
     it 'returns false when not running' do
+      subject.stop
+      sleep(0.1)
       subject.should_not be_running
     end
   end

data/spec/concurrent/scheduled_task_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'timecop'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -19,11 +20,19 @@ module Concurrent
       end
 
       let(:fulfilled_subject) do
-        ScheduledTask.new(0.1){ fulfilled_value }.execute.tap{ sleep(0.2) }
+        latch = Concurrent::CountDownLatch.new(1)
+        task = ScheduledTask.new(0.1){ latch.count_down; fulfilled_value }.execute
+        latch.wait(1)
+        sleep(0.1)
+        task
       end
 
       let(:rejected_subject) do
-        ScheduledTask.new(0.1){ raise rejected_reason }.execute.tap{ sleep(0.2) }
+        latch = Concurrent::CountDownLatch.new(1)
+        task = ScheduledTask.new(0.1){ latch.count_down; raise rejected_reason }.execute
+        latch.wait(1)
+        sleep(0.1)
+        task
       end
 
       it_should_behave_like :obligation
@@ -44,6 +53,17 @@ module Concurrent
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+      
+      subject{ ScheduledTask.new(0.1){ nil } }
+      
+      def trigger_observable(observable)
+        observable.execute
+        sleep(0.2)
+      end
+
+      it_should_behave_like :observable
     end
 
     context '#initialize' do
@@ -65,19 +85,19 @@ module Concurrent
       it 'raises an exception when seconds is less than zero' do
         expect {
           ScheduledTask.new(-1){ nil }
-        }.to raise_error(ScheduledTask::SchedulingError)
+        }.to raise_error(ArgumentError)
       end
 
       it 'raises an exception when schedule time is in the past' do
         expect {
           ScheduledTask.new(Time.now - 60){ nil }
-        }.to raise_error(ScheduledTask::SchedulingError)
+        }.to raise_error(ArgumentError)
       end
 
       it 'raises an exception when no block given' do
         expect {
           ScheduledTask.new(1)
-        }.to raise_error(ScheduledTask::SchedulingError)
+        }.to raise_error(ArgumentError)
       end
 
       it 'sets the initial state to :unscheduled' do
@@ -121,16 +141,10 @@ module Concurrent
           Timecop.travel(60)
           expect {
             task.execute
-          }.to raise_error(ScheduledTask::SchedulingError)
+          }.to raise_error(ArgumentError)
         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 sate to :pending' do
         task = ScheduledTask.new(1){ nil }
         task.execute
@@ -153,7 +167,7 @@ module Concurrent
       it 'passes the block to the new ScheduledTask' do
         @expected = false
         task = ScheduledTask.execute(0.1){ @expected = true }
-        sleep(0.2)
+        task.value(1)
         @expected.should be_true
       end
 
@@ -169,37 +183,39 @@ module Concurrent
 
       it 'returns false if the task has already been performed' do
         task = ScheduledTask.new(0.1){ 42 }.execute
-        sleep(0.2)
+        task.value(1)
         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 }.execute
-        sleep(0.2)
+        latch = Concurrent::CountDownLatch.new(1)
+        task = ScheduledTask.new(0.1) {
+          latch.count_down
+          sleep(1)
+        }.execute
+        latch.wait(1)
         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 }
+        latch = Concurrent::CountDownLatch.new(1)
+        task = ScheduledTask.new(0.1){ latch.count_down }
         task.cancel
         task.execute
-        sleep(0.5)
-        @expected.should be_true
+        latch.wait(0.3).should be_false
       end
 
 
       it 'cancels the task if it has not yet started' do
-        @expected = true
-        task = ScheduledTask.new(0.3){ @expected = false }.execute
+        latch = Concurrent::CountDownLatch.new(1)
+        task = ScheduledTask.new(0.3){ latch.count_down }.execute
         sleep(0.1)
         task.cancel
-        sleep(0.5)
-        @expected.should be_true
+        latch.wait(0.5).should be_false
       end
 
       it 'returns true on success' do
-        task = ScheduledTask.new(0.3){ @expected = false }.execute
+        task = ScheduledTask.new(10){ nil }.execute
         sleep(0.1)
         task.cancel.should be_true
       end
@@ -215,8 +231,12 @@ 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 }.execute
-        sleep(0.2)
+        latch = Concurrent::CountDownLatch.new(1)
+        task = ScheduledTask.new(0.1) {
+          latch.count_down
+          sleep(1)
+        }.execute
+        latch.wait(1)
         task.should be_in_progress
       end
     end
@@ -228,10 +248,15 @@ module Concurrent
           attr_reader :value
           attr_reader :reason
           attr_reader :count
-          define_method(:update) do |time, value, reason|
+          attr_reader :latch
+          def initialize
+            @latch = Concurrent::CountDownLatch.new(1)
+          end
+          def update(time, value, reason)
             @count = @count.to_i + 1
             @value = value
             @reason = reason
+            @latch.count_down
           end
         end
       end
@@ -262,22 +287,20 @@ module Concurrent
 
       it 'returns false for an observer added once :fulfilled' do
         task = ScheduledTask.new(0.1){ 42 }.execute
-        sleep(0.2)
+        task.value(1)
         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 }.execute
-        sleep(0.2)
+        task.value(0.2)
         task.add_observer(observer).should be_false
       end
 
       it 'notifies all observers on fulfillment' do
         task = ScheduledTask.new(0.1){ 42 }.execute
         task.add_observer(observer)
-        sleep(0.2)
-        task.value.should == 42
-        task.reason.should be_nil
+        observer.latch.wait(1)
         observer.value.should == 42
         observer.reason.should be_nil
       end
@@ -285,9 +308,7 @@ module Concurrent
       it 'notifies all observers on rejection' do
         task = ScheduledTask.new(0.1){ raise StandardError }.execute
         task.add_observer(observer)
-        sleep(0.2)
-        task.value.should be_nil
-        task.reason.should be_a(StandardError)
+        observer.latch.wait(1)
         observer.value.should be_nil
         observer.reason.should be_a(StandardError)
       end
@@ -295,7 +316,7 @@ module Concurrent
       it 'does not notify an observer added after fulfillment' do
         observer.should_not_receive(:update).with(any_args)
         task = ScheduledTask.new(0.1){ 42 }.execute
-        sleep(0.2)
+        task.value(1)
         task.add_observer(observer)
         sleep(0.1)
       end
@@ -303,7 +324,7 @@ module Concurrent
       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 }.execute
-        sleep(0.2)
+        task.value(1)
         task.add_observer(observer)
         sleep(0.1)
       end
@@ -313,9 +334,8 @@ module Concurrent
         task = ScheduledTask.new(0.1){ 42 }.execute
         task.cancel
         task.add_observer(observer)
-        sleep(0.2)
+        task.value(1)
       end
-
     end
   end
 end