Merge pull request #88 from jdantonio/refactor/brittle-specs

Refactor brittle specs

Author: jdantonio

spec/concurrent/exchanger_spec.rb

@@ -50,20 +50,15 @@ module Concurrent
       context 'with timeout' do
         it 'should block until timeout' do
 
-          latch = Concurrent::CountDownLatch.new(1)
           value = 0
           start = Time.now.to_f
 
-          t = Thread.new do
-            value = exchanger.exchange(2, 0.2)
-            latch.count_down
+          future = Concurrent::Future.execute do
+            exchanger.exchange(2, 0.2)
           end
-
-          latch.wait(1)
-
+          
+          future.value.should be_nil
           (Time.now.to_f - start).should >= 0.2
-          t.status.should be_false
-          value.should be_nil
         end
       end
     end

spec/concurrent/observable_shared.rb

@@ -135,6 +135,7 @@ def notify(*args)
         subject.add_observer(obs, observer_func)
       end
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 0
     end
 
@@ -144,6 +145,7 @@ def notify(*args)
         subject.add_observer{ latch.count_down }
       end
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 0
     end
 
@@ -155,6 +157,7 @@ def notify(*args)
       subject.delete_observer(obs)
 
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 5
     end
 
@@ -167,6 +170,7 @@ def notify(*args)
       subject.delete_observers
 
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 5
     end
   end

spec/concurrent/supervisor_spec.rb

@@ -23,8 +23,16 @@ def run() super(); sleep; end
 
     let(:stopper_class) do
       Class.new(worker_class) {
-        def initialize(sleep_time = 0.2) @sleep_time = sleep_time; end;
-        def run() super(); sleep(@sleep_time); end
+        attr_reader :latch
+        def initialize(sleep_time = 0.2)
+          @sleep_time = sleep_time
+          @latch = Concurrent::CountDownLatch.new(1)
+        end
+        def run
+          super
+          sleep(@sleep_time)
+          @latch.count_down
+        end
       }
     end
 
@@ -326,13 +334,18 @@ def mock_thread(status = 'run')
 
     context '#count' do
 
+      let(:stoppers){ Array.new }
+
       let(:busy_supervisor) do
         supervisor = Supervisor.new(monitor_interval: 60)
         3.times do
           supervisor.add_worker(sleeper_class.new)
-          supervisor.add_worker(stopper_class.new)
           supervisor.add_worker(error_class.new)
           supervisor.add_worker(runner_class.new)
+
+          stopper = stopper_class.new
+          stoppers << stopper
+          supervisor.add_worker(stopper)
         end
         supervisor
       end
@@ -426,15 +439,16 @@ def mock_thread(status = 'run')
       it 'returns the count of all stopped workers as #stopped' do
         busy_supervisor.count.stopped.should eq total_count
         busy_supervisor.run!
-        sleep(0.5)
+        stoppers.each{|stopper| stopper.latch.wait(1) }
 
         busy_supervisor.count.stopped.should eq stopped_count
       end
 
       it 'returns the count of all workers terminated by exception as #abend' do
         busy_supervisor.count.abend.should eq 0
         busy_supervisor.run!
-        sleep(0.5)
+        stoppers.each{|stopper| stopper.latch.wait(1) }
+        sleep(0.1)
 
         busy_supervisor.count.abend.should eq abend_count
       end
@@ -832,8 +846,8 @@ def mock_thread(status = 'run')
                                       monitor_interval: 0.1)
           supervisor.add_worker(error_class.new)
           supervisor.should_receive(:exceeded_max_restart_frequency?).once.and_return(true)
-          supervisor.run!
-          sleep(0.2)
+          future = Concurrent::Future.execute{ supervisor.run }
+          future.value(1)
           supervisor.should_not be_running
         end
 
@@ -842,8 +856,8 @@ def mock_thread(status = 'run')
                                       monitor_interval: 0.1)
           supervisor.add_worker(error_class.new)
           supervisor.should_receive(:exceeded_max_restart_frequency?).once.and_return(true)
-          supervisor.run!
-          sleep(0.2)
+          future = Concurrent::Future.execute{ supervisor.run }
+          future.value(1)
           supervisor.should_not be_running
         end
 
@@ -852,8 +866,8 @@ def mock_thread(status = 'run')
                                       monitor_interval: 0.1)
           supervisor.add_worker(error_class.new)
           supervisor.should_receive(:exceeded_max_restart_frequency?).once.and_return(true)
-          supervisor.run!
-          sleep(0.2)
+          future = Concurrent::Future.execute{ supervisor.run }
+          future.value(1)
           supervisor.should_not be_running
         end
       end

spec/concurrent/timer_task_spec.rb

@@ -171,23 +171,23 @@ def trigger_observable(observable)
       it 'runs the block immediately when the :run_now option is true' do
         latch = CountDownLatch.new(1)
         subject = TimerTask.execute(execution: 500, now: true){ latch.count_down }
-        latch.wait(0.1).should be_true
+        latch.wait(1).should be_true
         subject.kill
       end
 
       it 'waits for :execution_interval seconds when the :run_now option is false' do
         latch = CountDownLatch.new(1)
         subject = TimerTask.execute(execution: 0.1, now: false){ latch.count_down }
         latch.count.should eq 1
-        latch.wait(0.2).should be_true
+        latch.wait(1).should be_true
         subject.kill
       end
 
       it 'waits for :execution_interval seconds when the :run_now option is not given' do
         latch = CountDownLatch.new(1)
         subject = TimerTask.execute(execution: 0.1, now: false){ latch.count_down }
         latch.count.should eq 1
-        latch.wait(0.2).should be_true
+        latch.wait(1).should be_true
         subject.kill
       end
 
@@ -199,7 +199,7 @@ def trigger_observable(observable)
           latch.sount_down
         end
         subject.execute
-        latch.wait(0.2)
+        latch.wait(1)
         expected.should eq subject
         subject.kill
       end