aquarium 0.4.1 → 0.4.2

data/spec/aquarium/aspects/aspect_spec.rb

@@ -6,6 +6,22 @@ require 'logger'
 
 include Aquarium::Aspects
 
+class MyError1 < StandardError; end
+class MyError2 < StandardError; end
+class MyError3 < StandardError; end
+class ClassThatRaises
+  class CTRException < StandardError; end
+  def raises
+    raise CTRException
+  end
+end
+class ClassThatRaisesString
+  class CTRException < StandardError; end
+  def raises
+    raise "A string exception."
+  end
+end
+
 
 describe Aspect, " cannot advise the private implementation methods inserted by other aspects" do  
   it "should have no affect." do
@@ -69,18 +85,19 @@ describe Aspect, " with :before advice" do
 
   it "should pass the context information to the advice, including self and the method parameters." do
     watchful = Watchful.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :before
+      jp.context.advised_object.should == watchful
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :before
-    context.advised_object.should == watchful
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == nil
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should evaluate the advice before the method body and its block (if any)." do
@@ -98,18 +115,19 @@ describe Aspect, " with :after advice" do
 
   it "should pass the context information to the advice, including self, the method parameters, and the return value when the method returns normally." do
     watchful = Watchful.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :after, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :after
+      jp.context.advised_object.should == watchful
+      jp.context.returned_value.should == 1
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :after
-    context.advised_object.should == watchful
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == block_called
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should pass the context information to the advice, including self, the method parameters, and the rescued exception when an exception is raised." do
@@ -119,10 +137,12 @@ describe Aspect, " with :after advice" do
       context = jp.context
     end 
     block_called = 0
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.should raise_error(Watchful::WatchfulError)
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') do |*args| 
+      block_called += 1 
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+    end }.should raise_error(Watchful::WatchfulError)
     block_called.should == 1
     context.advised_object.should == watchful
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     context.returned_value.should == nil
     context.raised_exception.kind_of?(Watchful::WatchfulError).should be_true
   end
@@ -161,6 +181,18 @@ describe Aspect, " with :after advice" do
     end 
     ReturningValue.new.doit(ary).should == %w[aa a b c d e]
   end
+
+  it "should allow advice to change the exception raised" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new :after, :pointcut => {:type => ClassThatRaises, :methods => :raises} do |jp, obj, *args|
+      aspect_advice_invoked = true
+      jp.context.raised_exception = MyError1
+    end 
+    aspect_advice_invoked.should be_false
+    ctr = ClassThatRaises.new
+    lambda {ctr.raises}.should raise_error(MyError1)
+    aspect_advice_invoked.should be_true
+  end
 end
 
 describe Aspect, " with :after_returning advice" do  
@@ -170,18 +202,19 @@ describe Aspect, " with :after_returning advice" do
 
   it "should pass the context information to the advice, including self, the method parameters, and the return value." do
     watchful = Watchful.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :after_returning, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :after_returning
+      jp.context.advised_object.should == watchful
+      jp.context.returned_value.should == 1
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :after_returning
-    context.advised_object.should == watchful
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == block_called
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should evaluate the advice after the method body and its block (if any)." do
@@ -205,7 +238,7 @@ describe Aspect, " with :after_returning advice" do
     ReturningValue.new.doit(ary).should == %w[a b c d]
   end
 
-  it "should all the advice to assign a new return value" do
+  it "should allow the advice to change the returned value" do
     class ReturningValue
       def doit args
         args + ["d"]
@@ -220,10 +253,6 @@ describe Aspect, " with :after_returning advice" do
   end
 end
 
-class MyError1 < StandardError; end
-class MyError2 < StandardError; end
-class MyError3 < StandardError; end
-
 describe Aspect, " with :after_raising advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
@@ -231,18 +260,19 @@ describe Aspect, " with :after_raising advice" do
 
   it "should pass the context information to the advice, including self, the method parameters, and the rescued exception." do
     watchful = Watchful.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :after_raising, :pointcut => {:type => Watchful, :methods => /public_watchful_method/} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advised_object.should == watchful
+      jp.context.advice_kind.should == :after_raising
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.kind_of?(Watchful::WatchfulError).should be_true
     end 
     block_called = 0
     lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.should raise_error(Watchful::WatchfulError)
     block_called.should == 1
-    context.advised_object.should == watchful
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.advice_kind.should == :after_raising
-    context.returned_value.should == nil
-    context.raised_exception.kind_of?(Watchful::WatchfulError).should be_true
+    advice_called.should be_true
   end
 
   it "should evaluate the advice after the method body and its block (if any)." do
@@ -302,6 +332,14 @@ describe Aspect, " with :after_raising advice" do
     block_invoked.should be_true
   end
   
+  it "should invoke advice when an exception that subclasses a specified exception type is raised" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising => StandardError, :pointcut => {:type => ClassThatRaises, :methods => :raises}) {|jp, obj, *args| aspect_advice_invoked = true}
+    ctr = ClassThatRaises.new
+    lambda {ctr.raises}.should raise_error(ClassThatRaises::CTRException)
+    aspect_advice_invoked.should be_true
+  end
+  
   it "should not invoke advice when exceptions of types that don't match the specified list of exception types are raised" do
     aspect_advice_invoked = false
     @aspect = Aspect.new(:after_raising => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
@@ -339,12 +377,6 @@ describe Aspect, " with :after_raising advice" do
   end
   
   it "should advise all methods that raise exceptions when no specific exceptions are specified" do
-    class ClassThatRaises
-      class CTRException < Exception; end
-      def raises
-        raise CTRException
-      end
-    end
     aspect_advice_invoked = false
     @aspect = Aspect.new :after_raising, :pointcut => {:type => ClassThatRaises, :methods => :raises} do |jp, obj, *args|
       aspect_advice_invoked = true
@@ -356,12 +388,6 @@ describe Aspect, " with :after_raising advice" do
   end
 
   it "should advise all methods that raise strings (which are converted to RuntimeError) when no specific exceptions are specified" do
-    class ClassThatRaisesString
-      class CTRException < Exception; end
-      def raises
-        raise "A string exception."
-      end
-    end
     aspect_advice_invoked = false
     @aspect = Aspect.new :after_raising, :pointcut => {:type => ClassThatRaisesString, :methods => :raises} do |jp, obj, *args|
       aspect_advice_invoked = true
@@ -371,6 +397,18 @@ describe Aspect, " with :after_raising advice" do
     lambda {ctr.raises}.should raise_error(RuntimeError)
     aspect_advice_invoked.should be_true
   end
+
+  it "should allow advice to change the exception raised" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new :after_raising, :pointcut => {:type => ClassThatRaises, :methods => :raises} do |jp, obj, *args|
+      aspect_advice_invoked = true
+      jp.context.raised_exception = MyError1
+    end 
+    aspect_advice_invoked.should be_false
+    ctr = ClassThatRaises.new
+    lambda {ctr.raises}.should raise_error(MyError1)
+    aspect_advice_invoked.should be_true
+  end
 end
 
 describe Aspect, " with :before and :after advice" do  
@@ -379,22 +417,30 @@ describe Aspect, " with :before and :after advice" do
   end
 
   it "should pass the context information to the advice, including self and the method parameters, plus the return value for the after-advice case." do
+    # We record the contexts seen and the volatile advice kinds and returned values separately, as those values will have been
+    # reset in the contexts by the time we return from the advised method. 
     contexts = []
+    advice_kinds = []
+    returned_values = []
     @aspect = Aspect.new :before, :after, :pointcut => {:type => Watchful, :methods => [:public_watchful_method]} do |jp, obj, *args|
       contexts << jp.context
+      advice_kinds << jp.context.advice_kind
+      returned_values << jp.context.returned_value
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     watchful = Watchful.new
     public_block_called = 0
-    watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| public_block_called += 1 }
+    watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') do |*args| 
+      public_block_called += 1 
+    end
     public_block_called.should == 1
     contexts.size.should == 2
-    contexts[0].advice_kind.should == :before
-    contexts[1].advice_kind.should == :after
-    contexts[0].returned_value.should == nil
-    contexts[1].returned_value.should == 1
+    advice_kinds[0].should == :before
+    advice_kinds[1].should == :after
+    returned_values[0].should == nil
+    returned_values[1].should == 1
     contexts.each do |context|
       context.advised_object.should == watchful
-      context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
       context.raised_exception.should == nil
     end
 
@@ -421,21 +467,27 @@ describe Aspect, " with :before and :after_returning advice" do
 
   it "should pass the context information to the advice, including self and the method parameters, plus the return value for the after-advice case." do
     watchful = Watchful.new
+    # We record the contexts seen and the volatile advice kinds and returned values separately, as those values will have been
+    # reset in the contexts by the time we return from the advised method. 
     contexts = []
+    advice_kinds = []
+    returned_values = []
     @aspect = Aspect.new :before, :after_returning, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args|
       contexts << jp.context
+      advice_kinds << jp.context.advice_kind
+      returned_values << jp.context.returned_value
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
     contexts.size.should == 2
-    contexts[0].advice_kind.should == :before
-    contexts[1].advice_kind.should == :after_returning
-    contexts[0].returned_value.should == nil
-    contexts[1].returned_value.should == block_called
+    advice_kinds[0].should == :before
+    advice_kinds[1].should == :after_returning
+    returned_values[0].should == nil
+    returned_values[1].should == 1
     contexts.each do |context|
       context.advised_object.should == watchful
-      context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
       context.raised_exception.should == nil
     end
   end
@@ -455,21 +507,27 @@ describe Aspect, " with :before and :after_raising advice" do
 
   it "should pass the context information to the advice, including self and the method parameters, plus the raised exception for the after-advice case." do
     watchful = Watchful.new
+    # We record the contexts seen and the volatile advice kinds and raised exceptions separately, as those values will have been
+    # reset in the contexts by the time we return from the advised method. 
     contexts = []
+    advice_kinds = []
+    raised_exceptions = []
     @aspect = Aspect.new :before, :after_raising, :pointcut => {:type => Watchful, :methods => :public_watchful_method_that_raises} do |jp, obj, *args|
       contexts << jp.context
+      advice_kinds << jp.context.advice_kind
+      raised_exceptions << jp.context.raised_exception
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     block_called = 0
     lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.should raise_error(Watchful::WatchfulError)
     block_called.should == 1
     contexts.size.should == 2
-    contexts[0].advice_kind.should == :before
-    contexts[1].advice_kind.should == :after_raising
-    contexts[0].raised_exception.should == nil
-    contexts[1].raised_exception.kind_of?(Watchful::WatchfulError).should be_true
+    advice_kinds[0].should == :before
+    advice_kinds[1].should == :after_raising
+    raised_exceptions[0].should == nil
+    raised_exceptions[1].kind_of?(Watchful::WatchfulError).should be_true
     contexts.each do |context|
       context.advised_object.should == watchful
-      context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
       context.returned_value.should == nil
     end
   end
@@ -488,11 +546,16 @@ describe Aspect, " with :around advice" do
   end
 
   it "should pass the context information to the advice, including the object, advice kind, the method invocation parameters, etc." do
-    contexts = []
+    watchful = Watchful.new
+    advice_called = false
     @aspect = Aspect.new :around, :pointcut => {:type => Watchful, :methods => [:public_watchful_method]} do |jp, obj, *args|
-      contexts << jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advised_object.should == watchful
+      jp.context.advice_kind.should == :around
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
-    watchful = Watchful.new
     public_block_called = false
     protected_block_called = false
     private_block_called = false
@@ -502,12 +565,7 @@ describe Aspect, " with :around advice" do
     public_block_called.should be_false  # proceed is never called!
     protected_block_called.should be_true
     private_block_called.should be_true
-    contexts.size.should == 1
-    contexts[0].advised_object.should == watchful
-    contexts[0].advice_kind.should == :around
-    contexts[0].returned_value.should == nil
-    contexts[0].parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    contexts[0].raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should advise subclass invocations of methods advised in the superclass." do
@@ -529,11 +587,16 @@ describe Aspect, " with :around advice" do
       end
     end
     
-    context = nil
+    child = AdvisingSuperClass::SubClass.new
+    advice_called = false
     @aspect = Aspect.new :around, :pointcut => {:type => AdvisingSuperClass::SuperClass, :methods => [:public_method]} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advised_object.should == child
+      jp.context.advice_kind.should == :around
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
-    child = AdvisingSuperClass::SubClass.new
     public_block_called = false
     protected_block_called = false
     private_block_called = false
@@ -543,11 +606,7 @@ describe Aspect, " with :around advice" do
     public_block_called.should be_false  # proceed is never called!
     protected_block_called.should be_true
     private_block_called.should be_true
-    context.advised_object.should == child
-    context.advice_kind.should == :around
-    context.returned_value.should == nil
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should advise subclass invocations of methods advised in the subclass that are defined in the superclass." do
@@ -569,11 +628,16 @@ describe Aspect, " with :around advice" do
       end
     end
     
-    context = nil
+    child = AdvisingSubClass::SubClass.new
+    advice_called = false
     @aspect = Aspect.new :around, :pointcut => {:type => AdvisingSubClass::SuperClass, :methods => [:public_method]} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advised_object.should == child
+      jp.context.advice_kind.should == :around
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
-    child = AdvisingSubClass::SubClass.new
     public_block_called = false
     protected_block_called = false
     private_block_called = false
@@ -583,11 +647,7 @@ describe Aspect, " with :around advice" do
     public_block_called.should be_false  # proceed is never called!
     protected_block_called.should be_true
     private_block_called.should be_true
-    context.advised_object.should == child
-    context.advice_kind.should == :around
-    context.returned_value.should == nil
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should not advise subclass overrides of superclass methods, when advising superclasses (but calls to superclass methods are advised)." do

data/spec/aquarium/aspects/aspect_with_nested_types_spec.rb

@@ -30,34 +30,36 @@ describe Aspect, ".new when advising methods in a nested class" do
 
   it "should correctly advise methods in a nested class." do
     myclass = Nested1::Nested2::MyClass.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :before, :pointcut => {:type => Nested1::Nested2::MyClass, :methods => :do1} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :before
+      jp.context.advised_object.should == myclass
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     myclass.do1(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :before
-    context.advised_object.should == myclass
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == nil
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should correctly advise methods in an instance of the nested class." do
     myclass = Nested1::Nested2::MyClass.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :before, :pointcut => {:object => myclass, :methods => :do1} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :before
+      jp.context.advised_object.should == myclass
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     myclass.do1(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :before
-    context.advised_object.should == myclass
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == nil
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 end
 
@@ -72,18 +74,19 @@ describe Aspect, ".new when advising methods in a nested module included by a cl
     end
 
     myclass = MyClassWithModule1.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :before, :pointcut => {:type => Nested1::Nested2::MyModule, :methods => :do2} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :before
+      jp.context.advised_object.should == myclass
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     myclass.do2(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :before
-    context.advised_object.should == myclass
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == nil
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should correctly advise the module's methods when the class is specified." do
@@ -92,18 +95,19 @@ describe Aspect, ".new when advising methods in a nested module included by a cl
     end
 
     myclass = MyClassWithModule2.new
-    context = nil
+    advice_called = false
     @aspect = Aspect.new :before, :pointcut => {:type => MyClassWithModule2, :methods => :do2} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :before
+      jp.context.advised_object.should == myclass
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     myclass.do2(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :before
-    context.advised_object.should == myclass
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == nil
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 
   it "should correctly advise the module's methods when an instance of the class is specified." do
@@ -113,17 +117,19 @@ describe Aspect, ".new when advising methods in a nested module included by a cl
 
     myclass = MyClassWithModule3.new
     context = nil
+    advice_called = false
     @aspect = Aspect.new :before, :pointcut => {:object => myclass, :methods => :do2} do |jp, obj, *args|
-      context = jp.context
+      advice_called = true
+      args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
+      jp.context.advice_kind.should == :before
+      jp.context.advised_object.should == myclass
+      jp.context.returned_value.should == nil
+      jp.context.raised_exception.should == nil
     end 
     block_called = 0
     myclass.do2(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    context.advice_kind.should == :before
-    context.advised_object.should == myclass
-    context.parameters.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    context.returned_value.should == nil
-    context.raised_exception.should == nil
+    advice_called.should be_true
   end
 end