caricature 0.7.2 → 0.7.5

data/lib/caricature/clr/method_call_recorder.rb

@@ -0,0 +1,97 @@
+module Caricature
+  
+   # A recording that represents an event raise
+   # it contains argument variations that can be matched too
+   class EventRaiseRecording
+
+     # gets or sets the event name
+     attr_accessor :event_name
+
+     # gets or sets the amount of times the event was raised
+     attr_accessor :count
+
+     # gets or sets the arguments for this event raise
+     attr_accessor :args
+
+     # gets or sets the block for this event raise
+     attr_accessor :handler
+
+     # Initializes a new instance of a method call recording
+     # every time a method gets called in an isolated object
+     # this gets stored in the method call recorder
+     # It expects a +method_name+ at the very least.
+     def initialize(event_name, count=0)
+       @event_name = event_name
+       @count = count
+       @variations = []
+     end
+
+     # add args
+     def args
+       @variations
+     end
+
+     # indicates if it has an argument variation
+     def has_argument_variations?
+       @variations.size > 1
+     end
+
+     # add an argument variation
+     def add_argument_variation(args, block)
+       variation = find_argument_variations args
+       if variation.empty?
+         @variations << ArgumentRecording.new(args, @variations.size+1, block) if variation == []
+       else
+         variation.first.call_number += 1
+       end
+     end
+
+     # finds an argument variation that matches the provided +args+
+     def find_argument_variations(args)
+       return @variations if args.first.is_a?(Symbol) and args.last == :any
+       @variations.select { |ar| ar.args == args }
+     end
+     
+   end
+  
+  class MethodCallRecorder
+    
+    def event_raises
+      @event_raises ||= {}
+    end
+    
+    def record_event_raise(event_name, mode, *args, &handler)
+      en_sym = event_name.to_sym
+      event_raises[mode] ||= {}
+      ev = (event_raises[mode][en_sym] ||= EventRaiseRecording.new(event_name))
+      ev.count += 1
+      ev.add_argument_variation args, handler
+    end
+    
+    def event_error
+      @event_error
+    end
+    
+    # returns whether the event was actually raised with the specified constraints
+    def event_raised?(event_name, mode = :instance, *args)
+      mc = event_raises[mode][event_name.to_s.to_sym]  
+      if mc
+        vari = mc.find_argument_variations(args)
+        result = vari.any? { |agv| agv == args }
+        return result if result
+        if args.size == 1 and args.last.is_a?(Hash)
+          result = vari.any? do |agv|
+            agv.args.last.is_a?(Hash) and args.last.all? { |k, v| agv.args.last[k] == v }
+          end
+        end
+        @event_error = "Event Arguments don't match for #{event_name}.\n\nYou expected:\n#{args.join(", ")}.\n\nI did find the following variations:\n#{mc.args.collect {|ar| ar.args.join(', ') }.join(' and ')}" unless result
+        result
+      else
+        @event_error = "Couldn't find an event with name #{event_name}"
+        return !!mc
+      end
+    end
+    
+  end
+  
+end

data/lib/caricature/core_ext.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/core_ext/string'
+require File.dirname(__FILE__) + '/core_ext/class'
+require File.dirname(__FILE__) + '/core_ext/module'
+require File.dirname(__FILE__) + '/core_ext/object'
+require File.dirname(__FILE__) + '/core_ext/array'
+require File.dirname(__FILE__) + '/core_ext/hash'
+
+if defined? IRONRUBY_VERSION
+  require File.dirname(__FILE__) + '/core_ext/system/string'
+  require File.dirname(__FILE__) + '/core_ext/system/type'
+end

data/lib/{core_ext → caricature/core_ext}/system/type.rb

@@ -16,6 +16,12 @@ module System
       self.get_properties + iface_properties.flatten
     end
 
+    def collect_interface_events
+      iface_events = []
+      iface_events += self.get_interfaces.collect { |t| t.collect_interface_events }
+      self.get_events + iface_events.flatten.uniq
+    end
+
   end
 
 end

data/lib/caricature/expectation.rb

@@ -35,58 +35,66 @@ module Caricature
   # contains the syntax for building up an expectation
   # This is shared between the +ExpecationBuilder+ and the +Expectation+
   module ExpectationSyntax
+    
     # tell the expection which arguments it needs to respond to
     # there is a magic argument here +any+ which configures
     # the expectation to respond to any arguments
-    def with(*args, &b)
-      @any_args = args.first.is_a?(Symbol) and args.first == :any
-      @args = args   
-      @callback = b unless b.nil?
+    def with(*ags, &b)
+      collected[:any_args] = ags.first.is_a?(Symbol) and ags.first == :any
+      collected[:args] = ags   
+      collected[:callback] = b unless b.nil?
       self
     end
 
     # tell the expectation it nees to return this value or the value returned by the block
     # you provide to this method.
     def return(value=nil, &b)
-      @return_value = value
-      @return_callback = b if b
+      collected[:return_value] = value
+      collected[:return_callback] = b if b
       self
     end
 
     # Sets up arguments for the block that is being passed into the isolated method call
-    def pass_block(*args, &b)
-      @any_block_args = args.first.is_a?(Symbol) and args.first == :any
-      @block_args = args
-      @block_callback = b unless b.nil?
+    def pass_block(*ags, &b)
+      collected[:any_block_args] = ags.first.is_a?(Symbol) and args.first == :any
+      collected[:block_args] = ags
+      collected[:block_callback] = b unless b.nil?
       self
     end
 
     # tell the expectation it needs to raise an error with the specified arguments
     alias_method :actual_raise, :raise
     def raise(*args)
-      @error_args = args
+      collected[:error_args] = args
       self
     end
-
+    
     # tell the expecation it needs to call the super before the expectation exectution
     def super_before(&b)
-      @super = :before
-      @block = b if b
+      collected[:super] = :before
+      collected[:block] = b if b
       self
     end
-
+    
     # tell the expectation it needs to call the super after the expecation execution
     def super_after(&b)
-      @super = :after
-      @block = b if b
+      collected[:super] = :after
+      collected[:block] = b if b
       self
     end
 
     # indicates whether this expectation should match with any arguments
     # or only for the specified arguments
     def any_args?
-      @any_args
+      collected[:any_args]
     end
+    
+    
+    private
+    
+      def collected
+        @collected ||= {}
+      end
   end
 
   # A description of an expectation.
@@ -95,106 +103,140 @@ module Caricature
 
     include ExpectationSyntax
 
-    # gets the method_name to which this expectation needs to listen to
-    attr_reader :method_name
-
-    # the arguments that this expectation needs to be constrained by
-    attr_reader :args
-
     # the error_args that this expectation will raise an error with
-    attr_reader :error_args
+    def error_args
+      collected[:error_args]
+    end
 
     # the value that this expecation will return when executed
-    attr_reader :return_value
+    def return_value
+      collected[:return_value]
+    end
 
     # indicator for the mode to call the super +:before+, +:after+ and +nil+
-    attr_reader :super   
-                         
+    def super 
+      collected[:super]
+    end  
+
     # contains the callback if one is given
-    attr_reader :callback
+    def callback
+      collected[:callback]
+    end
 
     # contains the callback that is used to return the value when this expectation
     # is executed
-    attr_reader :return_callback
+    def return_callback
+      collected[:return_callback]
+    end
 
     # contains the arguments that will be passed on to the block
-    attr_reader :block_args
+    def block_args
+      collected[:block_args]
+    end
 
     # The block that will be used as value provider for the block in the method
-    attr_reader :block_callback
+    def block_callback
+      collected[:block_callback]
+    end
 
     # the block that will be used
-    attr_accessor :block
-
-
+    def block
+      collected[:block]
+    end
+    
+    # sets the block callback 
+    def block=(val)
+      collected[:block] = val
+    end
+    
+    # gets the method_name to which this expectation needs to listen to
+    def method_name 
+      collected[:method_name]
+    end
+    
+    # the arguments that this expectation needs to be constrained by
+    def args
+      collected[:args]
+    end
+    
     # Initializes a new instance of an expectation
-    def initialize(*args)
-      @method_name, @args, @error_args, @return_value, @return_callback,
-              @super, @callback, @block_args, @block_callback, @block = *args
-      @any_args = true
+    def initialize(options={})
+      collected[:any_args] = true
+      collected.merge!(options)
     end
-
+    
     # indicates whether this expecation will raise an event.
     def has_error_args?
-      !@error_args.nil?
+      !collected[:error_args].nil?
     end
 
     # indicates whether this expectation will return a value.
     def has_return_value?
-      !@return_value.nil?
+      !collected[:return_value].nil?
     end
 
     # call the super before the expectation
     def super_before?
-      @super == :before
+      collected[:super] == :before
     end
 
     # indicates whether super needs to be called somewhere
     def call_super?
-      !@super.nil?
+      !collected[:super].nil?
     end      
     
     # indicates whether this expecation has a callback it needs to execute
     def has_callback? 
-      !@callback.nil?
+      !collected[:callback].nil?
     end
-
+    
     # indicates whether this expectation has a block as value provider for the method call block
     def has_block_callback?
-      !@block_callback.nil?
+      !collected[:block_callback].nil?
     end
 
     # a flag to indicate it has a return value callback
     def has_return_callback?
-      !@return_callback.nil?
+      !collected[:return_callback].nil?
     end
     
     # executes this expectation with its configuration
     def execute(*margs,&b)
-      ags = any_args? ? (margs.empty? ? :any : margs) : args
-      actual_raise *@error_args if has_error_args?    
-      callback.call(*ags) if has_callback?
-
-      if b
-        if has_block_callback?
-          b.call(*@block_callback.call)
-        else
-          b.call(*@block_args)
-        end
-      end
+      ags = any_args? ? :any : (margs.empty? ? collected[:args] : margs)
+      do_raise_error
+      do_callback(ags)
+      do_block_callback(&b)
+      do_event_raise if respond_to?(:events)
 
-      return @return_callback.call(*margs) if has_return_callback?
+      return collected[:return_callback].call(*margs) if has_return_callback?
       return return_value if has_return_value? 
       nil
     end
 
-    def to_s
+    def to_s #:nodoc:
       "<Caricature::Expecation, method_name: #{method_name}, args: #{args}, error args: #{error_args}>"
     end
-
-    def inspect
-      to_s
+    alias :inspect :to_s
+    
+    
+    private 
+    
+    def do_raise_error #:nodoc:
+      actual_raise *collected[:error_args] if has_error_args?
+    end
+    
+    def do_callback(ags) #:nodoc:
+      callback.call(*ags) if has_callback?
     end
+    
+    def do_block_callback(&b) #:nodoc:
+      if b
+        ags = has_block_callback? ? collected[:block_callback].call : collected[:block_args]
+        b.call(*ags)
+      end
+    end
+    
+    
   end
 
   # Constructs the expecation object.
@@ -207,14 +249,14 @@ module Caricature
     # this builder is passed into the block to allow only certain
     # operations in the block.
     def initialize(method_name)
-      @method_name, @args, @any_args = method_name, [], true
+      @collected = { :method_name => method_name, :args => [], :any_args => true }
     end
 
 
 
     # build up the expectation with the provided arguments
     def build
-      Expectation.new @method_name, @args, @error_args, @return_value, @return_callback, @super, @callback, @block_args, @block_callback, @block
+      Expectation.new collected
     end
 
   end

data/lib/caricature/isolator.rb

@@ -214,6 +214,7 @@ module Caricature
       pxy.instance_variable_set("@___context___", context)
       pxy
     end
+ 
 
     class << self
 
@@ -280,17 +281,16 @@ module Caricature
         def initialize(*args)  
           self                      
         end 
-                   
+        
         cmembers.each do |mn|
           mn = mn.name.to_s.to_sym
           define_cmethod mn do |*args|        
+            return if mn.to_s =~ /$(singleton_)?method_added/ and args.first.to_s =~ /$(singleton_)?method_added/
             b = nil
             b = Proc.new { yield } if block_given?  
             isolation_context.send_class_message(mn, nil, *args, &b)
           end
         end   
-              
-
 
       end