Full specs for Async module (with a few pending.

Author: jdantonio

lib/concurrent/async.rb

@@ -47,6 +47,8 @@ module Concurrent
   #       when the object is used exclusively on a single thread. Use only
   #       asynchronous calls when the object is shared between threads.
   #
+  # @since 0.6.0
+  #
   # @see Concurrent::Obligation
   #
   # @see http://msdn.microsoft.com/en-us/library/hh191443.aspx Asynchronous Programming with Async and Await (C# and Visual Basic)
@@ -111,7 +113,7 @@ def initialize(delegate, mutex)
       #
       # @return [IVar] the result of the method call
       #
-      # @raise [NoMethodError] the object does not respond to +method+ method
+      # @raise [NameError] the object does not respond to +method+ method
       # @raise [ArgumentError] the given +args+ do not match the arity of +method+
       def method_missing(method, *args, &block)
         super unless @delegate.respond_to?(method)
@@ -128,7 +130,7 @@ def method_missing(method, *args, &block)
           rescue => reason
             # caught
           ensure
-            ivar.complete(reason.nil?, value, reason)
+            return ivar.complete(reason.nil?, value, reason)
           end
         end
 
@@ -163,7 +165,7 @@ def initialize(delegate, mutex)
       #
       # @return [IVar] the result of the method call
       #
-      # @raise [NoMethodError] the object does not respond to +method+ method
+      # @raise [NameError] the object does not respond to +method+ method
       # @raise [ArgumentError] the given +args+ do not match the arity of +method+
       def method_missing(method, *args, &block)
         super unless @delegate.respond_to?(method)
@@ -205,7 +207,7 @@ def method_missing(method, *args, &block)
     #
     # @return [Concurrent::Future] the pending result of the asynchronous operation
     #
-    # @raise [NoMethodError] the object does not respond to +method+ method
+    # @raise [NameError] the object does not respond to +method+ method
     # @raise [ArgumentError] the given +args+ do not match the arity of +method+
     #
     # @see Concurrent::Future
@@ -237,7 +239,7 @@ def async
     #
     # @return [Concurrent::IVar] the completed result of the synchronous operation
     #
-    # @raise [NoMethodError] the object does not respond to +method+ method
+    # @raise [NameError] the object does not respond to +method+ method
     # @raise [ArgumentError] the given +args+ do not match the arity of +method+
     #
     # @see Concurrent::IVar

spec/concurrent/async_spec.rb

@@ -4,14 +4,22 @@ module Concurrent
 
   describe Async do
 
-    described_class do
-      Class.new do
+    subject do
+      Class.new {
         include Concurrent::Async
         def echo(msg)
-          sleep(rand)
           msg
         end
-      end
+        def gather(first, second = nil)
+          return first, second
+        end
+        def boom(ex = StandardError.new)
+          raise ex
+        end
+        def wait(seconds)
+          sleep(seconds)
+        end
+      }.new
     end
 
     context '#validate_argc' do
@@ -40,7 +48,7 @@ def many(*args, &block) nil; end
       it 'does not raise an exception for correct zero arity' do
         expect {
           Async::validate_argc(subject, :zero)
-        }.to_not raise_error
+        }.not_to raise_error
       end
 
       it 'raises an exception for too many args on a method with positive arity' do
@@ -58,7 +66,7 @@ def many(*args, &block) nil; end
       it 'does not raise an exception for correct positive arity' do
         expect {
           Async::validate_argc(subject, :three, 1, 2, 3)
-        }.to_not raise_error
+        }.not_to raise_error
       end
 
       it 'raises an exception for too few args on a method with negative arity' do
@@ -76,16 +84,151 @@ def many(*args, &block) nil; end
           Async::validate_argc(subject, :many)
           Async::validate_argc(subject, :many, 1, 2)
           Async::validate_argc(subject, :many, 1, 2, 3, 4)
-        }.to_not raise_error
+        }.not_to raise_error
       end
     end
 
     context '#async' do
-      pending
+
+      it 'raises an error when calling a method that does not exist' do
+        expect {
+          subject.async.bogus
+        }.to raise_error(StandardError)
+      end
+
+      it 'raises an error when passing too few arguments' do
+        expect {
+          subject.async.gather
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an error when pasing too many arguments (arity >= 0)' do
+        expect {
+          subject.async.echo(1, 2, 3, 4, 5)
+        }.to raise_error(StandardError)
+      end
+
+      it 'returns a :pending Future' do
+        val = subject.async.wait(5)
+        val.should be_a Concurrent::Future
+        val.should be_pending
+      end
+
+      it 'sets the value on success' do
+        val = subject.async.echo(:foo)
+        val.value.should eq :foo
+        val.should be_fulfilled
+      end
+
+      it 'sets the reason on failure' do
+        ex = ArgumentError.new
+        val = subject.async.boom(ex)
+        sleep(0.1)
+        val.reason.should eq ex
+        val.should be_rejected
+      end
+
+      it 'sets the reason when giving too many optional arguments' do
+        val = subject.async.gather(1, 2, 3, 4, 5)
+        sleep(0.1)
+        val.reason.should be_a StandardError
+        val.should be_rejected
+      end
+
+      it 'defines the method after the first call' do
+        pending('failing inconsistently')
+        expect { subject.async.method(:echo) }.to raise_error(NameError)
+        subject.async.echo(:foo)
+        sleep(0.1)
+        expect { subject.async.method(:echo) }.not_to raise_error
+      end
+
+      it 'does not define the method on name/arity exception' do
+        pending('failing inconsistently')
+        expect { subject.async.method(:bogus) }.to raise_error(NameError)
+        expect { subject.async.bogus }.to raise_error(NameError)
+        expect { subject.async.method(:bogus) }.to raise_error(NameError)
+      end
+
+      it 'uses the same mutex as #await' do
+        subject.await.mutex.should eq subject.async.mutex
+      end
+
+      it 'is aliased as #future' do
+        val = subject.future.wait(5)
+        val.should be_a Concurrent::Future
+        val.should be_pending
+      end
     end
 
     context '#await' do
-      pending
+
+      it 'raises an error when calling a method that does not exist' do
+        expect {
+          subject.await.bogus
+        }.to raise_error(StandardError)
+      end
+
+      it 'raises an error when passing too few arguments' do
+        expect {
+          subject.await.gather
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an error when pasing too many arguments (arity >= 0)' do
+        expect {
+          subject.await.echo(1, 2, 3, 4, 5)
+        }.to raise_error(StandardError)
+      end
+
+      it 'returns a :fulfilled IVar' do
+        val = subject.await.echo(5)
+        val.should be_a Concurrent::IVar
+        val.should be_fulfilled
+      end
+
+      it 'sets the value on success' do
+        val = subject.await.echo(:foo)
+        val.value.should eq :foo
+        val.should be_fulfilled
+      end
+
+      it 'sets the reason on failure' do
+        ex = ArgumentError.new
+        val = subject.await.boom(ex)
+        val.reason.should eq ex
+        val.should be_rejected
+      end
+
+      it 'sets the reason when giving too many optional arguments' do
+        val = subject.await.gather(1, 2, 3, 4, 5)
+        val.reason.should be_a StandardError
+        val.should be_rejected
+      end
+
+      it 'defines the method after the first call' do
+        pending('failing inconsistently')
+        expect { subject.await.method(:echo) }.to raise_error(NameError)
+        subject.await.echo(:foo)
+        expect { subject.await.method(:echo) }.not_to raise_error
+      end
+
+      it 'does not define the method on name/arity exception' do
+        pending('failing inconsistently')
+        expect { subject.await.method(:bogus) }.to raise_error(NameError)
+        expect { subject.await.bogus }.to raise_error(NameError)
+        expect { subject.await.method(:bogus) }.to raise_error(NameError)
+      end
+
+      it 'uses the same mutex as #async' do
+        subject.await.mutex.should eq subject.async.mutex
+      end
+
+      it 'is aliased as #defer' do
+        val = subject.defer.echo(5)
+        val.should be_a Concurrent::IVar
+        val.should be_fulfilled
+      end
     end
   end
 end