exceptional_synchrony 1.0.1 → 1.1.1

data/test/unit/callback_exceptions_test.rb

@@ -1,4 +1,5 @@
 require_relative '../test_helper'
+require 'pry'
 
 describe ExceptionalSynchrony::CallbackExceptions do
   describe "ensure_callback" do
@@ -60,14 +61,14 @@ describe ExceptionalSynchrony::CallbackExceptions do
         deferrable = EM::DefaultDeferrable.new
         deferrable.succeed(12)
         result = ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        result.must_equal 12
+        expect(result).must_equal(12)
       end
 
       it "should map success values to an array" do
         deferrable = EM::DefaultDeferrable.new
         deferrable.succeed(12, 13, 14)
         result = ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        result.must_equal [12, 13, 14]
+        expect(result).must_equal([12, 13, 14])
       end
 
       it "should map success exception values to raise" do
@@ -77,7 +78,7 @@ describe ExceptionalSynchrony::CallbackExceptions do
         result = assert_raises(ArgumentError) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
         end
-        result.must_equal exception
+        expect(result).must_equal(exception)
       end
     end
 
@@ -87,8 +88,18 @@ describe ExceptionalSynchrony::CallbackExceptions do
         deferrable.fail(first: "a", last: "b")
         result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        end
-        result.message.must_equal "{:first=>\"a\", :last=>\"b\"}"
+        end.message
+        expect(result).must_equal("RESULT = {:first=>\"a\", :last=>\"b\"}")
+      end
+
+      it "should truncate long failures" do
+        deferrable = EM::DefaultDeferrable.new
+        deferrable.fail('a'*75 + 'b'*75)
+        result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end.message
+        expected_message = "RESULT = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb...TRUNC"
+        expect(result).must_equal(expected_message)
       end
 
       it "should map failure exceptions to raise" do
@@ -97,9 +108,9 @@ describe ExceptionalSynchrony::CallbackExceptions do
         deferrable.fail(exception)
         result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
-        end
-        result.message.must_match /ArgumentError/
-        result.message.must_match /Wrong argument!/
+        end.message
+        expect(result).must_match(/ArgumentError/)
+        expect(result).must_match(/Wrong argument!/)
       end
 
       it "should map timeout failure to raise TimeoutError" do
@@ -114,6 +125,47 @@ describe ExceptionalSynchrony::CallbackExceptions do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
         end
       end
+
+      it "should map Errno::ETIMEDOUT to TimeoutError" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          Errno::ETIMEDOUT
+        end
+
+        deferrable.fail(deferrable)
+        assert_raises(Timeout::Error) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+      end
+
+      it "should map other SystemCallError exceptions to Failures with the error in the message" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          Errno::ECONNREFUSED
+        end
+
+        deferrable.fail(deferrable)
+        result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+        expect(result.message).must_match(/\AERROR = Errno::ECONNREFUSED; RESULT = #<EventMachine::DefaultDeferrable/)
+      end
+
+      it "should map any other errors to Failure with the error in the message" do
+        deferrable = EM::DefaultDeferrable.new
+
+        def deferrable.error
+          ArgumentError.new("Some errror")
+        end
+
+        deferrable.fail(deferrable)
+        result = assert_raises(ExceptionalSynchrony::CallbackExceptions::Failure) do
+          ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
+        end
+        expect(result.message).must_match(/\AERROR = #<ArgumentError: Some errror>; RESULT = #<EventMachine::DefaultDeferrable/)
+      end
     end
 
     describe "no status" do
@@ -122,29 +174,29 @@ describe ExceptionalSynchrony::CallbackExceptions do
         result = assert_raises(ArgumentError) do
           ExceptionalSynchrony::CallbackExceptions.map_deferred_result(deferrable)
         end
-        result.message.must_match /no deferred status set yet/i
+        expect(result.message).must_match(/no deferred status set yet/i)
       end
     end
   end
 
   describe "return_exception" do
     it "should return the value if no exception" do
-      ExceptionalSynchrony::CallbackExceptions.return_exception do
+      expect(ExceptionalSynchrony::CallbackExceptions.return_exception do
         14
-      end.must_equal 14
+      end).must_equal(14)
     end
 
     it "should yield its args" do
-      ExceptionalSynchrony::CallbackExceptions.return_exception(0, 1) do |a, b|
+      expect(ExceptionalSynchrony::CallbackExceptions.return_exception(0, 1) do |a, b|
         assert_equal [0, 1], [a, b]
         14
-      end.must_equal 14
+      end).must_equal(14)
     end
 
     it "should rescue any exception that was raised and return it" do
-      ExceptionalSynchrony::CallbackExceptions.return_exception do
+      expect(ExceptionalSynchrony::CallbackExceptions.return_exception do
         raise ArgumentError, "An argument error occurred"
-      end.inspect.must_equal ArgumentError.new("An argument error occurred").inspect
+      end.inspect).must_equal(ArgumentError.new("An argument error occurred").inspect)
     end
   end
 end

data/test/unit/event_machine_proxy_test.rb

@@ -39,7 +39,45 @@ describe ExceptionalSynchrony::EventMachineProxy do
     ServerClass = Class.new
     mock(EventMachine).connect(ServerClass, 8080, :handler, :extra_arg).yields(:called)
     @em.connect(ServerClass, 8080, :handler, :extra_arg, &@block)
-    @yielded_value.must_equal :called
+    expect(@yielded_value).must_equal(:called)
+  end
+
+  describe "#yield_to_reactor" do
+    it "should give control to other threads when the reactor is running" do
+      mock(@em).reactor_running? { true }
+      mock(EventMachine::Synchrony).sleep(0)
+      @em.yield_to_reactor
+    end
+
+    it "should be a no-op if the reactor is not running" do
+      mock(@em).reactor_running? { false }
+      stub(EventMachine::Synchrony).sleep(0) { raise "Should not sleep!" }
+      @em.yield_to_reactor
+    end
+  end
+
+  describe "#defer" do
+    it "should output its block's output when it doesn't raise an error" do
+      ExceptionHandling.logger = Logger.new(STDERR)
+
+      @em.run do
+        assert_equal 12, @em.defer("#defer success") { 12 }
+        @em.stop
+      end
+    end
+
+    it "should raise an error when its block raises an error" do
+      ExceptionHandling.logger = Logger.new(STDERR)
+
+      @em.run do
+        ex = assert_raises(ArgumentError) do
+          @em.defer("#defer raising an error") { raise ArgumentError, "!!!" }
+        end
+
+        assert_equal "!!!", ex.message
+        @em.stop
+      end
+    end
   end
 
   EXCEPTION = ArgumentError.new('in block')
@@ -50,19 +88,19 @@ describe ExceptionalSynchrony::EventMachineProxy do
     end
 
     it "add_timer" do
-      mock(ExceptionHandling).log_error(EXCEPTION, "add_timer")
+      mock(ExceptionHandling).log_error(EXCEPTION, "add_timer", {})
       mock(EventMachine::Synchrony).add_timer(10) { |duration, *args| args.first.call }
       @em.add_timer(10) { raise EXCEPTION }
     end
 
     it "add_periodic_timer" do
-      mock(ExceptionHandling).log_error(EXCEPTION, "add_periodic_timer")
+      mock(ExceptionHandling).log_error(EXCEPTION, "add_periodic_timer", {})
       mock(EventMachine::Synchrony).add_periodic_timer(10) { |duration, *args| args.first.call }
       @em.add_periodic_timer(10) { raise EXCEPTION }
     end
 
     it "next_tick" do
-      mock(ExceptionHandling).log_error(EXCEPTION, "next_tick")
+      mock(ExceptionHandling).log_error(EXCEPTION, "next_tick", {})
       mock(EventMachine::Synchrony).next_tick { |*args| args.first.call }
       @em.next_tick { raise EXCEPTION }
     end
@@ -88,7 +126,7 @@ describe ExceptionalSynchrony::EventMachineProxy do
         proxy = ExceptionalSynchrony::EventMachineProxy.new(proxy_mock, nil)
 
         proxy.run(&@block)
-        @yielded_value.must_equal synchrony ? :synchrony : :run
+        expect(@yielded_value).must_equal(synchrony ? :synchrony : :run)
       end
     end
   end

data/test/unit/limited_work_queue_test.rb

@@ -4,13 +4,13 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
   end
 
   it "should raise an exception if created with a limit < 1" do
-    assert_raises(ArgumentError) do
+    expect(assert_raises(ArgumentError) do
       ExceptionalSynchrony::LimitedWorkQueue.new(@em, 0)
-    end.message.must_match /must be positive/
+    end.message).must_match(/must be positive/)
 
-    assert_raises(ArgumentError) do
+    expect(assert_raises(ArgumentError) do
       ExceptionalSynchrony::LimitedWorkQueue.new(@em, -2)
-    end.message.must_match /must be positive/
+    end.message).must_match(/must be positive/)
   end
 
   describe "when created" do
@@ -21,9 +21,9 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
     it "should run non-blocking jobs immediately" do
       c = 0
       ExceptionalSynchrony::EMP.run_and_stop do
-        @queue.add { c+=1 }
-        @queue.add { c+=1 }
-        @queue.add { c+=1 }
+        @queue.add! { c+=1 }
+        @queue.add! { c+=1 }
+        @queue.add! { c+=1 }
       end
       assert_equal 3, c
     end
@@ -46,9 +46,9 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
     it "should allow objects to be queued instead of Procs" do
       c = 0
       ExceptionalSynchrony::EMP.run_and_stop do
-        @queue.add(LWQTestProc.new { c+=1 })
-        @queue.add(LWQTestProc.new { c+=1 })
-        @queue.add(LWQTestProc.new { c+=1 })
+        @queue.add!(LWQTestProc.new { c+=1 })
+        @queue.add!(LWQTestProc.new { c+=1 })
+        @queue.add!(LWQTestProc.new { c+=1 })
       end
       assert_equal 3, c
     end
@@ -71,17 +71,17 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
       end
 
       ExceptionalSynchrony::EMP.run_and_stop do
-        @queue.add(job_proc)
+        @queue.add!(job_proc)
       end
     end
 
     it "should allow objects to merge themselves into the queue (canceling itself)" do
       c = 0
       ExceptionalSynchrony::EMP.run_and_stop do
-        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=1 })
-        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=2 })
-        @queue.add(LWQTestProcWithMergeDrop.new(-> { c+=4 }) { @em.sleep(0.001); c+=8 })
-        @queue.add(LWQTestProcWithMergeDrop.new(-> { c+=16 }) { @em.sleep(0.001); c+=32 }) # will get merged (by canceling self)
+        @queue.add!(LWQTestProc.new { @em.sleep(0.001); c+=1 })
+        @queue.add!(LWQTestProc.new { @em.sleep(0.001); c+=2 })
+        @queue.add!(LWQTestProcWithMergeDrop.new(-> { c+=4 }) { @em.sleep(0.001); c+=8 })
+        @queue.add!(LWQTestProcWithMergeDrop.new(-> { c+=16 }) { @em.sleep(0.001); c+=32 }) # will get merged (by canceling self)
         @em.sleep(0.050)
       end
       assert_equal 1+2+8+16, c
@@ -99,15 +99,35 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
     it "should allow objects to merge themselves into the queue (canceling/replacing earlier)" do
       c = 0
       ExceptionalSynchrony::EMP.run_and_stop do
-        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=1 })
-        @queue.add(LWQTestProc.new { @em.sleep(0.001); c+=2 })
-        @queue.add(LWQTestProcWithMergeReplace.new(-> { c+=4 }) { @em.sleep(0.001); c+=8 })
-        @queue.add(LWQTestProcWithMergeReplace.new(-> { c+=16 }) { @em.sleep(0.001); c+=32 }) # will get merged with above (replacing above)
+        @queue.add!(LWQTestProc.new { @em.sleep(0.001); c+=1 })
+        @queue.add!(LWQTestProc.new { @em.sleep(0.001); c+=2 })
+        @queue.add!(LWQTestProcWithMergeReplace.new(-> { c+=4 }) { @em.sleep(0.001); c+=8 })
+        @queue.add!(LWQTestProcWithMergeReplace.new(-> { c+=16 }) { @em.sleep(0.001); c+=32 }) # will get merged with above (replacing above)
         @em.sleep(0.050)
       end
       assert_equal 1+2+4+32, c
     end
 
+    it "should ensure that the queue continues to function even when an exception is raised" do
+      mock(ExceptionHandling).log_error(anything, /LimitedWorkQueue encountered an exception/).twice
+      ExceptionalSynchrony::EMP.run_and_stop do
+        c = 0
+        last_start = nil; end_0 = nil; end_1 = nil
+        @queue.add! { c += 1; @em.sleep(0.001); end_0 = c+=1; raise "Boom" }
+        @queue.add! { c += 1; @em.sleep(0.001); end_1 = c+=1; raise "Boom" }
+        @queue.add! { last_start = c+= 1; @em.sleep(0.001); c+=1 }
+
+        3.times do
+          @em.sleep(0.030)
+          break if c == 6
+        end
+
+        assert last_start && last_start > 3, "Unexpected value for last_start: #{last_start.inspect}"
+        assert [end_0, end_1].any? {|e| last_start > e }
+        assert_equal 6, c
+      end
+    end
+
     it "should run 2 blocking tasks in parallel and only start 3rd when one of the first 2 finishes" do
       stub_request(:get, "http://www.google.com/").
           to_return(:status => 200, :body => "1", :headers => {})
@@ -121,12 +141,12 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
       ExceptionalSynchrony::EMP.run_and_stop do
         c = -1
         started2 = nil; ended0 = nil; ended1 = nil
-        @queue.add { c+=1; @em.sleep(0.001); ExceptionalSynchrony::EMP.connection.new("http://www.google.com").get; ended0 = c+=1 }
-        @queue.add { c+=1; @em.sleep(0.001); ExceptionalSynchrony::EMP.connection.new("http://www.cnn.com").get; ended1 = c+=1 }
-        @queue.add { started2 = c+=1; ExceptionalSynchrony::EMP.connection.new("http://news.ycombinator.com").get; c+=1 }
+        @queue.add! { c+=1; @em.sleep(0.001); ExceptionalSynchrony::EMP.connection.new("http://www.google.com").get; ended0 = c+=1 }
+        @queue.add! { c+=1; @em.sleep(0.001); ExceptionalSynchrony::EMP.connection.new("http://www.cnn.com").get; ended1 = c+=1 }
+        @queue.add! { started2 = c+=1; ExceptionalSynchrony::EMP.connection.new("http://news.ycombinator.com").get; c+=1 }
 
         3.times do
-          @em.sleep(0.005)
+          @em.sleep(0.030)
           break if c == 5
         end
 
@@ -135,5 +155,183 @@ describe ExceptionalSynchrony::LimitedWorkQueue do
         assert started2 > ended0 || started2 > ended1, [ended0, ended1, started2].inspect
       end
     end
+
+    describe '#paused?' do
+      it 'should return false when @paused is false' do
+        @queue.instance_variable_set(:@paused, false)
+        assert_equal false, @queue.paused?
+      end
+
+      it 'should return true when @paused is true' do
+        @queue.instance_variable_set(:@paused, false)
+        assert_equal false, @queue.paused?
+      end
+    end
+
+    describe '#pause!' do
+      it 'should set @paused to true if @paused is currently false' do
+        assert_equal false, @queue.instance_variable_get('@paused')
+        @queue.pause!
+        assert_equal true, @queue.instance_variable_get('@paused')
+      end
+
+      it 'should set @paused to true if @paused is currently true' do
+        @queue.instance_variable_set(:@paused, true)
+        assert_equal true, @queue.instance_variable_get('@paused')
+        @queue.pause!
+        assert_equal true, @queue.instance_variable_get('@paused')
+      end
+    end
+
+    describe '#unpause!' do
+      it 'should set @paused to false if @paused is currently false' do
+        assert_equal false, @queue.instance_variable_get('@paused')
+        @queue.unpause!
+        assert_equal false, @queue.instance_variable_get('@paused')
+      end
+
+      it 'should set @paused to false if @paused is currently true' do
+        @queue.instance_variable_set(:@paused, true)
+        assert_equal true, @queue.instance_variable_get('@paused')
+        @queue.unpause!
+        assert_equal false, @queue.instance_variable_get('@paused')
+      end
+    end
+
+    describe '#add!' do
+      it 'should run jobs added to the queue when paused? is false' do
+        assert_equal false, @queue.paused? # queue#paused is false be default
+        counter = 0
+        ExceptionalSynchrony::EMP.run_and_stop do
+          3.times { @queue.add! { counter+=1 } }
+        end
+
+        assert_equal 0, @queue.instance_variable_get("@job_procs").size
+        assert_equal 3, counter
+      end
+
+      it 'should not run jobs added to the queue when paused? is true' do
+        @queue.pause!
+        assert_equal true, @queue.paused?
+        counter = 0
+        ExceptionalSynchrony::EMP.run_and_stop do
+          3.times { @queue.add! { counter+=1 } }
+        end
+
+        mock(@queue).work!.never
+        assert_equal 3, @queue.instance_variable_get("@job_procs").size
+        assert_equal 0, counter
+      end
+
+      it 'should have a method alias to #add for callers using the previous #add method' do
+        assert_equal @queue.method(:add!), @queue.method(:add)
+      end
+    end
+
+    describe '#items' do
+      it 'should return job_procs array' do
+        assert_equal 0, @queue.items.size
+        job_procs = Array.new(3) { Proc.new { puts 'Hello World' } }
+        @queue.instance_variable_set(:@job_procs, job_procs)
+        assert_equal 3, @queue.items.size
+      end
+    end
+
+    describe '#work!' do
+      before do
+        @queue = ExceptionalSynchrony::LimitedWorkQueue.new(@em, 2)
+      end
+
+      it 'should run items in queue' do
+        counter = 0
+        job_procs = Array.new(3) { Proc.new { counter += 1} }
+        @queue.instance_variable_set(:@job_procs, job_procs)
+        mock.proxy(Fiber).new.with_any_args.times(3)
+        @queue.work!
+
+        assert_equal 0, @queue.instance_variable_get("@job_procs").size
+        assert_equal 3, counter
+      end
+
+      it 'should run items already in queue, even if queue is paused' do
+        @queue.pause!
+        counter = 4
+        job_procs = Array.new(3) { Proc.new { counter += 1} }
+        @queue.instance_variable_set(:@job_procs, job_procs)
+        assert_equal 3, @queue.instance_variable_get("@job_procs").size
+        mock.proxy(Fiber).new.with_any_args.times(3)
+
+        @queue.work!
+
+        assert_equal 7, counter
+        assert_equal 0, @queue.instance_variable_get("@job_procs").size
+      end
+
+      it 'should not run if queue_empty' do
+        stub(@queue).queue_empty? { true }
+        counter = 0
+        job_procs = Array.new(3) { Proc.new { counter += 1} }
+        @queue.instance_variable_set(:@job_procs, job_procs)
+        assert_equal 3, @queue.instance_variable_get("@job_procs").size
+        mock(Fiber).new.never
+
+        @queue.work!
+        assert_equal 0, counter
+      end
+
+      it 'should not run if workers are full' do
+        stub(@queue).workers_full? { true }
+        counter = 0
+        job_procs = Array.new(3) { Proc.new { counter += 1} }
+        @queue.instance_variable_set(:@job_procs, job_procs)
+
+        assert_equal 3, @queue.instance_variable_get("@job_procs").size
+        mock(Fiber).new.never
+
+        @queue.work!
+        assert_equal 0, counter
+      end
+    end
+
+    describe '#workers_full?' do
+      before do
+        @queue = ExceptionalSynchrony::LimitedWorkQueue.new(@em, 2) # limit the number of active workers to 2 max
+      end
+
+      it 'should return true if the number of current workers is greater than the queue\'s defined worker limit' do
+        @queue.instance_variable_set(:@worker_count, 20)
+        @queue.instance_variable_set(:@limit, 10)
+        assert_equal true, @queue.workers_full?
+      end
+
+      it 'should return true if the current number of workers is equal to the queue\'s defined worker limit' do
+        @queue.instance_variable_set(:@worker_count, 10)
+        @queue.instance_variable_set(:@limit, 10)
+        assert_equal true, @queue.workers_full?
+      end
+
+      it 'should return false if the current number of workers is less than the queue\'s defined worker limit' do
+        @queue.instance_variable_set(:@worker_count, 5)
+        @queue.instance_variable_set(:@limit, 10)
+        assert_equal false, @queue.workers_full?
+      end
+    end
+
+    describe '#queue_empty?' do
+      before do
+        @queue = ExceptionalSynchrony::LimitedWorkQueue.new(@em, 2)
+      end
+
+      it 'should return true if queue is empty' do
+        @queue.instance_variable_set(:@job_procs, [])
+        assert_equal true, @queue.queue_empty?
+      end
+
+      it 'should return false if queue is not empty' do
+        @queue.instance_variable_set(:@job_procs, [Proc.new { 'hello'}])
+        assert_equal false, @queue.queue_empty?
+      end
+    end
+
   end
 end

data/test/unit/parallel_sync_test.rb

@@ -56,15 +56,15 @@ describe ExceptionalSynchrony::ParallelSync do
     stub_request(:get, "http://news.ycombinator.com/").
         to_return(:status => 200, :body => "3", :headers => {})
 
-    assert_raises(NotImplementedError) do
+    expect(assert_raises(NotImplementedError) do
       ExceptionalSynchrony::EMP.run_and_stop do
-        responses = ExceptionalSynchrony::ParallelSync.parallel(@em) do |parallel|
+        ExceptionalSynchrony::ParallelSync.parallel(@em) do |parallel|
           parallel.add { ExceptionalSynchrony::EMP.connection.new("http://www.google.com").get; raise NotImplementedError, "Not implemented!" }
           parallel.add { ExceptionalSynchrony::EMP.connection.new("http://www.cnn.com").get }
           parallel.add { ExceptionalSynchrony::EMP.connection.new("http://news.ycombinator.com").get }
         end
       end
-    end.to_s.must_match(/Not implemented!/)
+    end.to_s).must_match(/Not implemented!/)
   end
 
   it "should pass several exceptions through and raise them on the other side" do
@@ -77,15 +77,15 @@ describe ExceptionalSynchrony::ParallelSync do
     stub_request(:get, "http://news.ycombinator.com/").
         to_return(:status => 200, :body => "3", :headers => {})
 
-    assert_raises(NotImplementedError) do
+    expect(assert_raises(NotImplementedError) do
       ExceptionalSynchrony::EMP.run_and_stop do
-        responses = ExceptionalSynchrony::ParallelSync.parallel(@em) do |parallel|
+        ExceptionalSynchrony::ParallelSync.parallel(@em) do |parallel|
           parallel.add { ExceptionalSynchrony::EMP.connection.new("http://www.google.com").get; raise NotImplementedError, "Not implemented!" }
           parallel.add { ExceptionalSynchrony::EMP.connection.new("http://www.cnn.com").get; raise LoadError, "A load error occurred" }
           parallel.add { ExceptionalSynchrony::EMP.connection.new("http://news.ycombinator.com").get; raise IndexError, "An index error occurred" }
         end
       end
-    end.message.must_match(/Not implemented!.*LoadError: A load error occurred.*IndexError: An index error occurred/m)
+    end.message).must_match(/Not implemented!.*LoadError: A load error occurred.*IndexError: An index error occurred/m)
   end
 
   class TestProc