caricature 0.7.2 → 0.7.5

data/lib/caricature/clr/event_verification.rb

@@ -0,0 +1,57 @@
+module Caricature
+
+  # Describes a verification of a method call.
+  # This corresponds kind of to an assertion
+  class EventVerification 
+
+    # Initializes a new instance of a +Verification+
+    def initialize(event_name, recorder, mode=:instance)
+      @event_name, @args, @any_args, @recorder, @mode = event_name, [], true, recorder, mode
+      init_plugin
+    end
+    
+    def init_plugin
+      
+    end
+
+    # indicates whether this verification can be for any arguments
+    def any_args?
+      @any_args
+    end
+
+    # constrain this verification to the provided arguments
+    def with(*args)
+      @any_args = args.first.is_a?(Symbol) and args.first == :any
+      @args = args 
+     # @callback = b if b
+      self
+    end
+
+    # allow any arguments ignore the argument constraint
+    def allow_any_arguments
+      @any_args = true
+      self
+    end
+
+    # figure out if this argument variation matches the provided args.
+    def matches?(event_name, *args)
+      @event_name == event_name and (any_args? or @args == args)
+    end
+
+    def error
+      @recorder.event_error
+    end
+
+    # indicate that this method verification is successful
+    def successful?
+      a = any_args? ? [:any] : @args
+      begin
+        @recorder.event_raised?(@event_name, @mode, *a)
+      rescue ArgumentError
+        false
+      end
+    end
+
+  end
+
+end

data/lib/caricature/clr/expectation.rb

@@ -0,0 +1,101 @@
+module Caricature
+  
+  # Syntax for the expectation builder and expectation
+  # to define an event on the expectation.
+  module EventExpectationSyntax
+    
+    # tell the expectation it needs to raise an event when this method is called
+    def raise_event(name, *ags, &b)
+      collected.merge!(:event_name => name, :event_args => ags, :event_handler => b)
+      self
+    end
+    
+    # raises the events that has been registered on the object at runtime
+    def raise_subscriptions
+      collected[:raise_subscriptions] = true
+      self
+    end
+    
+  end
+  
+  
+  # Adds event support to the expectation
+  # this is only applicable to clr isolations and not
+  # to ruby isolations
+  class Expectation
+    
+    include EventExpectationSyntax
+    
+    
+    
+    # the block that will be used
+    def event_name
+      collected[:event_name]
+    end
+    
+    # the arguments that will be used for the event
+    def event_args
+      evt_ags = collected[:event_args]
+      evt_ags.nil? or evt_ags.empty? ? [nil, System::EventArgs.empty] : evt_ags
+    end
+    
+    # the block that will be used# the block that will be used
+    def event_handler
+      collected[:event_handler] || lambda { |s,e| }
+    end
+    
+    # the events attached to the context
+    def events
+      collected[:events] ||= {}
+    end
+    
+    # Set the registered events for this expectation
+    def events=(evts)
+      collected[:events]=evts
+    end
+    
+    # indicates whether this expectation has an event that needs to be raised
+    def raises_event?
+      !!collected[:event_name]
+    end
+    
+    # indicates whether this expectation has an event handler to be called 
+    def has_event_handler?
+      !!collected[:event_handler]
+    end
+    
+    # indicates whether to raise the registered event handlers
+    def raises_registered?
+      !!collected[:raise_subscriptions]
+    end
+   
+    def event_recorder(&b)
+      @event_recorder = b
+    end
+    
+    def to_s #:nodoc:
+      "<Caricature::Expecation, method_name: #{method_name}, args: #{args}, error args: #{error_args}, event: #{event_name}>"
+    end
+    alias :inspect :to_s
+    
+    private 
+    
+    def do_event_raise #:nodoc:
+      return unless @event_recorder
+      @event_recorder.call event_name, event_args, event_handler
+      return unless raises_event?
+      
+      ags = event_args
+      event_handler.call *ags if has_event_handler?
+      
+      return unless raises_registered? or not has_event_handler?
+      events[event_name].each { |evt| call_handler evt, *ags }
+    end
+    
+    def call_handler(evt, *ags)
+      evt.respond_to?(:call) ? evt.call(*ags) : evt.get_invocation_list.each{|ev| ev.invoke(*ags) }
+    end
+  end
+
+  ExpectationBuilder.send :include, EventExpectationSyntax
+end

data/lib/caricature/clr/isolation.rb

@@ -1,7 +1,48 @@
 module Caricature
+  
+  
 
-  class Isolation
+  class Isolation # :nodoc:
+
+    # the event subscriptions collected at runtime
+    attr_reader :events
+    
+    # the event subscriptions collected at runtime
+    def events
+      @events ||= {}
+    end
+
+    # adds an event subscription
+    def add_event_subscription(event_name, mode, handler)
+      events[mode] ||= {}
+      nm = event_name_for(event_name)
+      events[mode][nm] ||= []
+      events[mode][nm] << handler
+    end
+
+    # removes an event subscription
+    def remove_event_subscription(event_name, mode, handler)
+      ((events[mode] ||= {})[event_name_for(event_name)] ||=[]).delete(handler)
+    end
+    
+    # def add_event_expectation(name, mode, *args, &handler)
+    # end
+    
+    def internal_create_override(method_name, mode=:instance, &block)
+      builder = ExpectationBuilder.new method_name
+      block.call builder unless block.nil?
+      exp = builder.build
+      exp.events = events[mode]         
+      expectations.add_expectation exp, mode
+      exp
+    end
     
+    def verify_event_raise(event_name, mode= :instance, &block)
+      verification = EventVerification.new(event_name, recorder, mode)
+      block.call verification unless block.nil?
+      verification
+    end
+
     class << self
 
       # Creates an isolation object complete with proxy and method call recorder
@@ -12,7 +53,7 @@ module Caricature
         isolation_strategy = subject.clr_type? ? get_clr_isolation_strategy(subject) : RubyIsolator
 
         isolator = isolation_strategy.for context
-        isolation = new(isolator, context)
+        new(isolator, context)
         isolator.isolation
       end
 
@@ -26,17 +67,12 @@ module Caricature
           ClrIsolator
         end
     end 
-    
-    protected
-    
-      def internal_create_override(method_name, mode=:instance, &block)
-        builder = ExpectationBuilder.new method_name
-        block.call builder unless block.nil?
-        exp = builder.build           
-      
-        expectations.add_expectation exp, mode
-        exp
-      end
+
+    private
+
+    def event_name_for(method_name) #:nodoc:
+      method_name.gsub(/^(add|remove)_/, '').underscore.to_sym
+    end
 
   end
 

data/lib/caricature/clr/isolator.rb

@@ -1,5 +1,107 @@
 module Caricature
 
+  # Groups the methods for interception together
+  # this is a mix-in for the created isolations for classes
+  module Interception
+
+    # the class methods of this intercepting object
+    module ClassMethods
+
+      # Raises an event on the isolation
+      # You can specify the arguments in the block or as parameters
+      #
+      # Example
+      #
+      #     an_isolation.class.raise_event :on_property_changed do |raiser|
+      #       raiser.with an_isolation, System::EventArgs.empty
+      #     end
+      #
+      # is equivalent to:
+      #
+      #     an_isolation.class.raise_event :on_property_changed, an_isolation, System::EventArgs.empty
+      #
+      # or
+      #
+      #     an_isolation.class.raise_event(:on_property_changed).with(an_isolation, System::EventArgs.empty)
+      #
+      # You will most likely use this method when you want to verify logic in an event handler
+      # You will most likely use this method when you want to verify logic in an event handler
+      def raise_event(event_name, *args, &block)
+        isolation_context.add_event_expectation event_name, :class, *args, &block
+      end
+      
+      # Verifies whether the specified event was raised
+      #
+      # You will probably be using this method only when you're interested in whether an event has been raised
+      # during the course of the test you're running.
+      def did_raise_event?(event_name, &b)
+        isolation_context.verify_event_raise event_name, :class, &b
+      end
+
+    end
+
+    # Raises an event on the isolation
+    # You can specify the arguments in the block or as parameters
+    #
+    # Example
+    #
+    #     an_isolation.raise_event :on_property_changed do |raiser|
+    #       raiser.with an_isolation, System::EventArgs.empty
+    #     end
+    #
+    # is equivalent to:
+    #
+    #     an_isolation.raise_event :on_property_changed, an_isolation, System::EventArgs.empty
+    #
+    # or
+    #
+    #     an_isolation.raise_event(:on_property_changed).with(an_isolation, System::EventArgs.empty)
+    #
+    # You will most likely use this method when you want to verify logic in an event handler
+    def raise_event(event_name, *args, &block)
+      isolation_context.add_event_expectation event_name, :instance, *args, &block
+    end
+
+    # Raises an event on the isolation
+    # You can specify the arguments in the block or as parameters
+    #
+    # Example
+    #
+    #     an_isolation.raise_class_event :on_property_changed do |raiser|
+    #       raiser.with an_isolation, System::EventArgs.empty
+    #     end
+    #
+    # is equivalent to:
+    #
+    #     an_isolation.raise_class_event :on_property_changed, an_isolation, System::EventArgs.empty
+    #
+    # or
+    #
+    #     an_isolation.raise_class_event(:on_property_changed).with(an_isolation, System::EventArgs.empty)
+    #
+    # You will most likely use this method when you want to verify logic in an event handler
+    def raise_class_event(event_name, *args, &block)
+      self.class.raise_event event_name, *args, &block
+    end
+
+    # Verifies whether the specified event was raised
+    #
+    # You will probably be using this method only when you're interested in whether an event has been raised
+    # during the course of the test you're running.
+    def did_raise_event?(event_name, &b)
+      isolation_context.verify_event_raise event_name, :instance, &b
+    end
+    
+    # Verifies whether the specified event was raised
+    #
+    # You will probably be using this method only when you're interested in whether an event has been raised
+    # during the course of the test you're running.
+    def did_raise_class_event?(event_name, &b)
+      self.class.did_raise_event? event_name, &b
+    end
+
+  end
+
   # A proxy to CLR objects that records method calls.
   # this implements all the public instance methods of the class when you use it in ruby code
   # When you use it in a CLR class you're bound to CLR rules and it only overrides the methods
@@ -28,9 +130,11 @@ module Caricature
     end
 
     # builds the Isolator class for the specified subject
-    def  create_isolation_for(subj)
+    def create_isolation_for(subj)
       members = @descriptor.instance_members
       class_members = @descriptor.class_members
+      events = @descriptor.events
+      class_events = @descriptor.class_events
 
       klass = Object.const_set(class_name(subj), Class.new(subj))
       klass.class_eval do
@@ -40,10 +144,10 @@ module Caricature
         # access to the proxied subject
         def ___super___
           isolation_context.instance
-        end      
-        
-        def initialize(*args)  
-          self                      
+        end
+
+        def initialize(*args)
+          self
         end
 
         members.each do |mem|
@@ -63,6 +167,23 @@ module Caricature
             isolation_context.send_class_message(mn, nil, *args, &b)
           end
         end
+        
+       evts = (events + class_events).collect do |evt|
+         %w(add remove).inject("") do |res, nm|
+           res << <<-end_event_definition
+           
+def #{"self." unless evt.instance_member?}#{nm}_#{evt.event_name}(block)
+  self.isolation_context.#{nm}_event_subscription('#{evt.event_name}', :#{evt.instance_member? ? "instance" : "class"}, block)
+end
+ 
+           end_event_definition
+         end
+
+        end.join("\n")
+
+        klass.class_eval evts
+        
+        #puts evts
 
       end
 
@@ -92,6 +213,7 @@ module Caricature
     # builds the actual +isolator+ for the CLR interface
     def create_isolation_for(subj)
       proxy_members = @descriptor.instance_members
+      events = @descriptor.events
 
       klass = Object.const_set(class_name(subj), Class.new)
       klass.class_eval do
@@ -108,8 +230,22 @@ module Caricature
           end
         end
 
+
       end
 
+      evts = events.collect do |evt|
+       %w(add remove).inject("") do |res, nm|
+         res << <<-end_event_definition
+
+def #{"self." unless evt.instance_member?}#{nm}_#{evt.event_name}(block)
+  isolation_context.#{nm}_event_subscription('#{evt.event_name}', :#{evt.instance_member? ? "instance" : "class"}, block)
+end
+
+         end_event_definition
+       end
+      end.join("\n")
+      klass.class_eval evts
+
       klass
     end
   end

data/lib/caricature/clr/messenger.rb

@@ -14,6 +14,9 @@ module Caricature
         if exp
           block = exp.block || b
           res = instance.__send__(method_name, *args, &block) if exp.super_before?
+          exp.event_recorder do |ev_nm, ev_ar, ev_h|
+            recorder.record_event_raise ev_nm, mode, *ev_ar, &ev_h if ev_nm
+          end if recorder && exp
           res = exp.execute *args, &bl
           res = instance.__send__(method_name, *args, &block) if !exp.super_before? and exp.call_super?
         end
@@ -33,6 +36,9 @@ module Caricature
         res = nil                                               
         is_value_type = return_type && return_type != System::Void.to_clr_type && return_type.is_value_type
         exp = expectations.find(method_name, mode, *args)
+        exp.event_recorder do |ev_nm, ev_ar, ev_h|
+          recorder.record_event_raise ev_nm, mode, *ev_ar, &ev_h if ev_nm
+        end if recorder && exp
         bl = record_call(method_name, mode, exp, *args, &b)
         res = exp.execute *args, &bl if exp
         res ||= System::Activator.create_instance(return_type) if is_value_type