Fixed or deprecated all remaining pending specs.

jdantonio · jdantonio · commit 3ef1b1a02988 · 2014-04-14T21:27:37.000-04:00
diff --git a/lib/concurrent/actor/actor_ref.rb b/lib/concurrent/actor/actor_ref.rb
@@ -1,12 +1,9 @@
-require 'concurrent/observable'
-
 module Concurrent
 
   # Base class for classes that encapsulate `ActorContext` objects.
   #
   # @see Concurrent::ActorContext
   module ActorRef
-    include Concurrent::Observable
 
     # @!method post(*msg, &block)
     #
diff --git a/lib/concurrent/actor/simple_actor_ref.rb b/lib/concurrent/actor/simple_actor_ref.rb
@@ -13,10 +13,9 @@ def initialize(actor, opts = {})
       @mutex = Mutex.new
       @executor = SingleThreadExecutor.new
       @stop_event = Event.new
-      @reset_on_error = opts.fetch(:reset_on_error, false)
+      @reset_on_error = opts.fetch(:reset_on_error, true)
       @exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
       @args = opts.fetch(:args, {})
-      self.observers = CopyOnNotifyObserverSet.new
 
       @actor.define_singleton_method(:shutdown, &method(:set_stop_event))
       @actor.on_start
@@ -89,8 +88,6 @@ def process_message(message)
         rescue @exception_class => ex
           # suppress
         end
-
-        observers.notify_observers(now, message.payload, result, ex)
       end
     end
   end
diff --git a/spec/concurrent/actor/actor_ref_shared.rb b/spec/concurrent/actor/actor_ref_shared.rb
@@ -263,57 +263,4 @@ def receive(*msg)
       sleep(0.1)
     end
   end
-
-  context 'observation' do
-
-    let(:observer_class) do
-      Class.new do
-        attr_reader :time, :msg, :value, :reason
-        def update(time, msg, value, reason)
-          @msg = msg
-          @time = time
-          @value = value
-          @reason = reason
-        end
-      end
-    end
-
-    it 'notifies observers' do
-      o1 = observer_class.new
-      o2 = observer_class.new
-
-      subject.add_observer(o1)
-      subject.add_observer(o2)
-
-      subject << :foo
-      sleep(0.1)
-
-      o1.value.should eq :foo
-      o1.reason.should be_nil
-
-      o2.value.should eq :foo
-      o2.reason.should be_nil
-    end
-
-    it 'does not notify removed observers' do
-      o1 = observer_class.new
-      o2 = observer_class.new
-
-      subject.add_observer(o1)
-      subject.add_observer(o2)
-
-      subject << :foo
-      sleep(0.1)
-
-      subject.delete_observer(o1)
-      subject << :bar
-      sleep(0.1)
-      o1.value.should_not eq :bar
-
-      subject.delete_observers
-      subject << :baz
-      sleep(0.1)
-      o1.value.should_not eq :baz
-    end
-  end
 end
diff --git a/spec/concurrent/actor/actor_spec.rb b/spec/concurrent/actor/actor_spec.rb
@@ -132,25 +132,26 @@ def update(time, message, value, reason)
         }.new
       end
 
-      it 'notifies observers when a message is successfully handled' do
-        pending('intermittently failing; deprecated')
-        observer.should_receive(:update).exactly(10).times.with(any_args())
-        subject.add_observer(observer)
-        @thread = Thread.new{ subject.run }
-        @thread.join(0.1)
-        10.times { subject.post(42) }
-        @thread.join(0.1)
-      end
-
-      it 'notifies observers when a message raises an exception' do
-        error = StandardError.new
-        observer.should_receive(:update).exactly(10).times.with(any_args())
-        subject.add_observer(observer)
-        @thread = Thread.new{ subject.run }
-        @thread.join(0.1)
-        10.times { subject.post(error) }
-        @thread.join(0.1)
-      end
+      #it 'notifies observers when a message is successfully handled' do
+        #pending('intermittently failing; deprecated')
+        #observer.should_receive(:update).exactly(10).times.with(any_args())
+        #subject.add_observer(observer)
+        #@thread = Thread.new{ subject.run }
+        #@thread.join(0.1)
+        #10.times { subject.post(42) }
+        #@thread.join(0.1)
+      #end
+
+      #it 'notifies observers when a message raises an exception' do
+        #pending('intermittently failing; deprecated')
+        #error = StandardError.new
+        #observer.should_receive(:update).exactly(10).times.with(any_args())
+        #subject.add_observer(observer)
+        #@thread = Thread.new{ subject.run }
+        #@thread.join(0.1)
+        #10.times { subject.post(error) }
+        #@thread.join(0.1)
+      #end
 
       it 'passes the time, message, value, and reason to the observer on success' do
         subject.add_observer(observer)
@@ -243,18 +244,18 @@ def update(time, message, value, reason)
         @thread.kill
       end
 
-      it 'posts to the mailbox with Poolbox#<<' do
-        pending('intermittently failing; deprecated')
-        @expected = false
-        mailbox, pool = clazz.pool(1)
-        @thread = Thread.new{ pool.first.run }
-        sleep(0.1)
-        mailbox << 42
-        sleep(0.1)
-        pool.first.last_message.should eq [42]
-        pool.first.stop
-        @thread.kill
-      end
+      #it 'posts to the mailbox with Poolbox#<<' do
+        #pending('intermittently failing; deprecated')
+        #@expected = false
+        #mailbox, pool = clazz.pool(1)
+        #@thread = Thread.new{ pool.first.run }
+        #sleep(0.1)
+        #mailbox << 42
+        #sleep(0.1)
+        #pool.first.last_message.should eq [42]
+        #pool.first.stop
+        #@thread.kill
+      #end
     end
 
     context 'subclassing' do
diff --git a/spec/concurrent/actor/simple_actor_ref_spec.rb b/spec/concurrent/actor/simple_actor_ref_spec.rb
@@ -62,11 +62,11 @@ module Concurrent
         ref.post(:poison)
       end
 
-      it 'defaults to false' do
+      it 'defaults to true' do
         clazz = create_actor_test_class
         args = [:foo, :bar, :hello, :world]
         ref = clazz.spawn(args: args)
-        clazz.should_not_receive(:new).with(any_args)
+        clazz.should_receive(:new).once.with(*args)
         ref.post(:poison)
       end
     end
diff --git a/spec/concurrent/atomic/event_spec.rb b/spec/concurrent/atomic/event_spec.rb
@@ -44,11 +44,19 @@ module Concurrent
 
     context '#try?' do
 
-      it 'triggers the event if not already set'
+      it 'triggers the event if not already set' do
+        subject.try?
+        subject.should be_set
+      end
 
-      it 'returns true if not previously set'
+      it 'returns true if not previously set' do
+        subject.try?.should be_true
+      end
 
-      it 'returns false if previously set'
+      it 'returns false if previously set' do
+        subject.set
+        subject.try?.should be_false
+      end
     end
 
     context '#reset' do
diff --git a/spec/concurrent/executor/safe_task_executor_spec.rb b/spec/concurrent/executor/safe_task_executor_spec.rb
@@ -9,54 +9,94 @@ module Concurrent
       context 'happy execution' do
 
         let(:task) { Proc.new { 42 } }
-        let(:executor) { SafeTaskExecutor.new(task) }
+        subject { SafeTaskExecutor.new(task) }
 
         it 'should return success' do
-          success, value, reason = executor.execute
+          success, value, reason = subject.execute
           success.should be_true
         end
 
         it 'should return task value' do
-          success, value, reason = executor.execute
+          success, value, reason = subject.execute
           value.should eq 42
         end
 
         it 'should return a nil reason' do
-          success, value, reason = executor.execute
+          success, value, reason = subject.execute
           reason.should be_nil
         end
 
-        it 'passes all arguments to #execute to the task'
+        it 'passes all arguments to #execute to the task' do
+          expected = nil
+          task = proc {|*args| expected = args }
+          SafeTaskExecutor.new(task).execute(1, 2, 3)
+          expected.should eq [1, 2, 3]
+        end
 
-        it 'protectes #execute with a mutex'
+        it 'protectes #execute with a mutex' do
+          mutex = double(:mutex)
+          Mutex.should_receive(:new).with(no_args).and_return(mutex)
+          mutex.should_receive(:synchronize).with(no_args)
+          subject.execute
+        end
       end
 
       context 'failing execution' do
 
         let(:task) { Proc.new { raise StandardError.new('an error') } }
-        let(:executor) { SafeTaskExecutor.new(task) }
+        subject { SafeTaskExecutor.new(task) }
 
         it 'should return false success' do
-          success, value, reason = executor.execute
+          success, value, reason = subject.execute
           success.should be_false
         end
 
         it 'should return a nil value' do
-          success, value, reason = executor.execute
+          success, value, reason = subject.execute
           value.should be_nil
         end
 
         it 'should return the reason' do
-          success, value, reason = executor.execute
+          success, value, reason = subject.execute
           reason.should be_a(StandardError)
           reason.message.should eq 'an error'
         end
 
-        it 'rescues Exception when :rescue_exception is true'
+        it 'rescues Exception when :rescue_exception is true' do
+          task = proc { raise Exception }
+          subject = SafeTaskExecutor.new(task, rescue_exception: true)
+          expect {
+            subject.execute
+          }.to_not raise_error
+        end
 
-        it 'rescues StandardError when :rescue_exception is false'
+        it 'rescues StandardError when :rescue_exception is false' do
+          task = proc { raise StandardError }
+          subject = SafeTaskExecutor.new(task, rescue_exception: false)
+          expect {
+            subject.execute
+          }.to_not raise_error
+
+          task = proc { raise Exception }
+          subject = SafeTaskExecutor.new(task, rescue_exception: false)
+          expect {
+            subject.execute
+          }.to raise_error(Exception)
+        end
 
-        it 'rescues StandardError by default'
+        it 'rescues StandardError by default' do
+          task = proc { raise StandardError }
+          subject = SafeTaskExecutor.new(task)
+          expect {
+            subject.execute
+          }.to_not raise_error
+
+          task = proc { raise Exception }
+          subject = SafeTaskExecutor.new(task)
+          expect {
+            subject.execute
+          }.to raise_error(Exception)
+        end
       end
     end
   end
diff --git a/spec/concurrent/executor/thread_pool_shared.rb b/spec/concurrent/executor/thread_pool_shared.rb
@@ -195,13 +195,6 @@
       subject.length.should eq 0
     end
 
-    it 'returns a non-zero while shutting down' do
-      pending('intermittently failing on Travis CI')
-      5.times{ subject.post{ sleep(0.1) } }
-      subject.shutdown
-      subject.length.should > 0
-    end
-
     it 'returns zero once shut down' do
       5.times{ subject.post{ sleep(0.1) } }
       sleep(0.1)
diff --git a/spec/concurrent/executor/timer_set_spec.rb b/spec/concurrent/executor/timer_set_spec.rb
@@ -35,7 +35,16 @@ module Concurrent
       latch.wait(0.2).should be_true
     end
 
-    it 'passes all arguments to the task on execution'
+    it 'passes all arguments to the task on execution' do
+      expected = nil
+      latch = CountDownLatch.new(1)
+      subject.post(0.1, 1, 2, 3) do |*args|
+        expected = args
+        latch.count_down
+      end
+      latch.wait(0.2).should be_true
+      expected.should eq [1, 2, 3]
+    end
 
     it 'immediately posts a task when the delay is zero' do
       Thread.should_not_receive(:new).with(any_args)
diff --git a/spec/concurrent/timer_task_spec.rb b/spec/concurrent/timer_task_spec.rb
diff --git a/spec/concurrent/utility/timer_spec.rb b/spec/concurrent/utility/timer_spec.rb

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,9 @@`
`1`		`-require 'concurrent/observable'`
`2`		`-`
`3`	`1`	`module Concurrent`
`4`	`2`
`5`	`3`	# Base class for classes that encapsulate `ActorContext` objects.
`6`	`4`	`#`
`7`	`5`	`# @see Concurrent::ActorContext`
`8`	`6`	`module ActorRef`
`9`		`- include Concurrent::Observable`
`10`	`7`
`11`	`8`	`# @!method post(*msg, &block)`
`12`	`9`	`#`