casualjim-caricature 0.1.0

data/README

@@ -0,0 +1,29 @@
+Caricature - Bringing simple mocking to the DLR
+===============================================
+
+This project aims to make interop between IronRuby objects and .NET objects easier.
+The idea is that it integrates nicely with bacon and later rspec and that it transparently lets you mock ironruby ojbects
+as well as CLR objects/interfaces.
+Caricature handles interfaces, interface inheritance, CLR objects, CLR object instances, Ruby classes and instances of Ruby classes.
+
+From the start I wanted to do away with names like mock, stub, record, replay, verify etc.
+Instead I took the advice from Roy Osherhove and went with a name of Isolation for creating a mock.
+
+An Isolation will create what in Rhino.Mocks would be called a DynamicMock (but can be a partial too) :)
+In Moq it would be the Loose mocking strategy.
+
+The naming of the methods for creating mocks is the one that JP Boodhoo proposed WhenToldTo and WasToldTo.
+To specify a stub/expectation on a mock you have one and only one way of doing that with the method called when_told_to.
+Then only if you're interested in asserting if a method has been called you can use the was_told_to? method for this.
+
+
+mock = Isolation.for(Ninja)
+mock.when_told_to(:attack) do |exp|
+  exp.with(:shuriken)
+  exp.return(3)
+end
+
+Battle.new(mock)
+battle.combat
+
+mock.was_told_to?(:attack).should.be.true?

data/README.markdown

@@ -0,0 +1,30 @@
+Caricature - Bringing simple mocking to the DLR
+===============================================
+
+This project aims to make interop between IronRuby objects and .NET objects easier.
+The idea is that it integrates nicely with bacon and later rspec and that it transparently lets you mock ironruby ojbects
+as well as CLR objects/interfaces.
+Caricature handles interfaces, interface inheritance, CLR objects, CLR object instances, Ruby classes and instances of Ruby classes.
+
+From the start I wanted to do away with names like mock, stub, record, replay, verify etc.
+Instead I took the advice from Roy Osherhove and went with a name of Isolation for creating a mock.
+
+An Isolation will create what in Rhino.Mocks would be called a DynamicMock (but can be a partial too) :)
+In Moq it would be the Loose mocking strategy.
+
+The naming of the methods for creating mocks is the one that JP Boodhoo proposed WhenToldTo and WasToldTo.
+To specify a stub/expectation on a mock you have one and only one way of doing that with the method called when_told_to.
+Then only if you're interested in asserting if a method has been called you can use the was_told_to? method for this.
+
+<pre>
+mock = Isolation.for(Ninja)
+mock.when_told_to(:attack) do |exp|
+  exp.with(:shuriken)
+  exp.return(3)
+end
+
+Battle.new(mock)
+battle.combat
+
+mock.was_told_to?(:attack).should.be.true?
+</pre>

data/spec/bacon_helper.rb

@@ -0,0 +1,63 @@
+$: << File.dirname(__FILE__) + "/bin"
+$: << File.dirname(__FILE__) + "/../lib"
+
+require "caricature"
+require 'bacon'
+require 'mscorlib'
+
+
+
+
+load_assembly 'ClrModels'
+
+class Soldier
+
+  def name
+    "Tommy Boy"
+  end
+
+  def to_s
+    "I'm a soldier"
+  end
+
+end
+
+module Caricature
+
+  module InterfaceIncludingModule
+    include ClrModels::IWarrior
+  end
+
+  module PureRubyModule
+    
+  end
+
+  module RubyModuleIncludingModule
+    include PureRubyModule
+  end
+
+  module InterfaceUpTheWazoo
+    include InterfaceIncludingModule
+  end
+
+  class InterfaceIncludingClass
+    include ClrModels::IWarrior
+  end
+
+  class SubClassingClrClass < ClrModels::Ninja
+
+  end
+
+  class InterfaceUpTheWazooClass
+    include InterfaceUpTheWazoo
+  end
+
+  class SubclassingRubyClass < Soldier
+
+  end
+
+  class ModuleIncludingClass
+    include RubyModuleIncludingModule
+  end
+end
+

data/spec/core_ext_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "String" do
+
+  it "should underscore a camel cased name" do
+    "MockingAndStubbingForIronRuby1".underscore.should.equal "mocking_and_stubbing_for_iron_ruby1"
+  end
+
+  it "should get the class if it exists" do
+    "String".classify.should.equal String
+  end
+
+end
+
+describe "Module" do
+
+  it "should strip the module names" do
+    ClrModels::IExposingWarrior.demodulize.should.equal "IExposingWarrior"
+  end
+
+  it "should identify it's not a CLR type for a Ruby defined module" do
+    Caricature.is_clr_type?.should.be.false?
+  end
+
+  it "should identify it's a CLR type for a CLR defined interface" do
+    ClrModels::IExposingWarrior.is_clr_type?.should.be.true?
+  end
+
+  it "should identify it's a CLR type for a Ruby defined module that includes a CLR interface" do
+    Caricature::InterfaceIncludingModule.is_clr_type?.should.be.true?
+  end
+
+  it "should identify it's not a CLR type for a Ruby defined module that includes a Ruby module" do
+    Caricature::RubyModuleIncludingModule.is_clr_type?.should.be.false?
+  end
+
+  it "should identify it's a CLR type when an ancestor includes a CLR interface" do
+    Caricature::InterfaceUpTheWazoo.is_clr_type?.should.be.true?
+  end
+
+end
+
+describe "Class" do
+
+  it "should strip the module names" do
+    ClrModels::Ninja.demodulize.should.equal "Ninja"
+  end
+
+  it "should identify it's not a CLR type for a ruby defined type" do
+    Soldier.is_clr_type?.should.be.false?
+  end
+
+  it "should identify it's not a CLR type for a ruby defined type that subclasses a Ruby class" do
+    Caricature::SubclassingRubyClass.is_clr_type?.should.be.false?
+  end
+
+  it "should identify it's not a CLR type for a ruby defined type that includes only ruby modueles in its hierarchy" do
+    Caricature::ModuleIncludingClass.is_clr_type?.should.be.false?
+  end
+
+  it "should identify it's a CLR type for a type defined in C#" do
+    ClrModels::Ninja.is_clr_type?.should.be.true?
+  end
+
+  it "should identify it's a CLR type for a type defined in Ruby that includes a CLR interface" do
+    Caricature::InterfaceIncludingClass.is_clr_type?.should.be.true?
+  end
+
+  it "should identify it's a CLR type for a type defined in Ruby that subclasses a CLR class" do
+    Caricature::SubClassingClrClass.is_clr_type?.should.be.true?
+  end
+
+  it "should identify it's a CLR type for a type defined in Ruby that includes a CLR interface in its hierarchy" do
+    Caricature::InterfaceUpTheWazooClass.is_clr_type?.should.be.true?
+  end
+
+end
+

data/spec/expectation_spec.rb

@@ -0,0 +1,190 @@
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "Caricature::ExpectationBuilder" do
+
+  it "should create an expectation builder" do
+    builder = Caricature::ExpectationBuilder.new :some_method, nil
+    builder.should.not.equal nil
+  end
+
+  describe "when using all defaults" do
+
+    before do
+      builder = Caricature::ExpectationBuilder.new :some_method, nil
+      @expectation = builder.build
+    end
+
+    it "should have the correct method_name" do
+      @expectation.method_name.should.equal :some_method
+    end
+
+    it "should have empty args" do
+      @expectation.args.should.be.empty?
+    end
+
+    it "should have no super call" do
+      @expectation.super.should.equal nil
+    end
+
+    it "should have no error args" do
+      @expectation.error_args.should.equal nil
+    end
+
+    it "should have no return_value" do
+      @expectation.return_value.should.equal nil
+    end
+
+  end
+
+  describe "when specifying only arguments" do
+
+    before do
+      builder = Caricature::ExpectationBuilder.new :some_method,nil
+      builder.with(1, 2, 3)
+      @expectation = builder.build
+    end
+
+    it "should have the correct method_name" do
+      @expectation.method_name.should.equal :some_method
+    end
+
+    it "should have empty args" do
+      @expectation.args.should.equal [1,2,3]
+    end
+
+    it "should have no super call" do
+      @expectation.super.should.equal nil
+    end
+
+    it "should have no error args" do
+      @expectation.error_args.should.equal nil
+    end
+
+    it "should have no return_value" do
+      @expectation.return_value.should.equal nil
+    end
+
+  end
+
+  describe "when specifying only a block for the return value" do
+
+    before do
+      builder = Caricature::ExpectationBuilder.new :some_method, nil
+      builder.return {  5 }
+      @expectation = builder.build
+    end
+
+    it "should have the correct method_name" do
+      @expectation.method_name.should.equal :some_method
+    end
+
+    it "should have empty args" do
+      @expectation.args.should.be.empty?
+    end
+
+    it "should have no super call" do
+      @expectation.super.should.equal nil
+    end
+
+    it "should have no error args" do
+      @expectation.error_args.should.equal nil
+    end
+
+    it "should have the correct return_value" do
+      @expectation.return_value.should.equal 5
+    end
+
+  end
+
+  describe "when specifying a return value" do
+
+    before do
+      builder = Caricature::ExpectationBuilder.new :some_method, nil
+      builder.return 5
+      @expectation = builder.build
+    end
+
+    it "should have the correct method_name" do
+      @expectation.method_name.should.equal :some_method
+    end
+
+    it "should have empty args" do
+      @expectation.args.should.be.empty?
+    end
+
+    it "should have no super call" do
+      @expectation.super.should.equal nil
+    end
+
+    it "should have no error args" do
+      @expectation.error_args.should.equal nil
+    end
+
+    it "should have the correct return_value" do
+      @expectation.return_value.should.equal 5
+    end
+
+  end
+
+  describe "when specifying a raise arguments" do
+
+    before do
+      @msg = "Hold on, that wasn't supposed to happen"
+      builder = Caricature::ExpectationBuilder.new :some_method, nil
+      builder.raise @msg
+      @expectation = builder.build
+    end
+
+    it "should have the correct method_name" do
+      @expectation.method_name.should.equal :some_method
+    end
+
+    it "should have empty args" do
+      @expectation.args.should.be.empty?
+    end
+
+    it "should have no super call" do
+      @expectation.super.should.equal nil
+    end
+
+    it "should have no error args" do
+      @expectation.error_args.should.equal [@msg]
+    end
+
+    it "should have the correct return_value" do
+      @expectation.return_value.should.equal nil
+    end
+
+  end
+
+  describe "when specifying a return value and telling you want a call to super before" do
+
+    before do
+      builder = Caricature::ExpectationBuilder.new :some_method, nil
+      builder.return(5).super_before
+      @expectation = builder.build
+    end
+
+    it "should have the correct method_name" do
+      @expectation.method_name.should.equal :some_method
+    end
+
+    it "should have empty args" do
+      @expectation.args.should.be.empty?
+    end
+
+    it "should have no super call" do
+      @expectation.super.should.equal :before
+    end
+
+    it "should have no error args" do
+      @expectation.error_args.should.equal nil
+    end
+
+    it "should have the correct return_value" do
+      @expectation.return_value.should.equal 5
+    end
+
+  end
+
+end

data/spec/interop_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "Event handling" do
+
+
+
+  describe "for precompiled CLR classes" do
+
+    before do
+      @warrior = ClrModels::ExposingWarrior.new
+    end
+
+    it "should subscribe to an event" do
+      ClrModels::ExposedChangedSubscriber.new(@warrior)
+      @warrior.has_event_subscriptions.should.be.true?
+    end
+
+    it "should not raise an error when subcribing to an event" do
+      lambda { ClrModels::ExposedChangedSubscriber.new(@warrior) }.should.not.raise
+    end
+
+    it "should handle an event when raised" do
+      subscriber = ClrModels::ExposedChangedSubscriber.new(@warrior)
+      @warrior.change_is_exposed
+      subscriber.counter.should.equal 1
+    end
+
+  end
+
+  describe "for an IR generated interface proxy" do
+
+    before do
+      @proxy = Caricature::RecordingClrProxy.new ClrModels::IExposingWarrior
+    end
+
+    # apparently events don't work yet in IronRuby.. keeping this spec here to find out when it does
+#    it "should not raise an error when subcribing to an event" do
+#      lambda { ClrModels::ExposedChangedSubscriber.new(@proxy.subject) }.should.not.raise
+#    end
+
+  end
+
+end

data/spec/isolator_spec.rb

@@ -0,0 +1,139 @@
+# Caricature -- A simple mocking framework for IronRuby
+#
+# Copyright (c) 2009, Caricature Team
+# http://github.com/casualjim/caricature
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms,
+# with or without modification, are permitted provided
+# that the following conditions are met:
+#
+#    * Redistributions of source code must retain the
+#    above copyright notice, this list of conditions and
+#    the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce
+#    the above copyright notice, this list of conditions
+#    and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#    * Neither the name of the Caricature Team nor the
+#    names of its contributors may be used to endorse
+#    or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+# [This is the BSD license, see
+#  http://www.opensource.org/licenses/bsd-license.php]
+
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "Caricature::Isolation" do
+
+  describe "when creating an isolation for ruby objects" do
+
+    it "should not raise" do
+      lambda { Caricature::Isolation.for(Soldier) }.should.not.raise
+    end
+
+  end
+
+  describe "after creation of the isolation for a ruby object" do
+
+    before do
+      @isolator = Caricature::Isolation.for(Soldier)
+    end
+
+    it "should create a proxy" do
+      @isolator.proxy.should.not.be == nil
+    end
+
+    it "should create the Ruby objects proxy" do
+      @isolator.proxy.is_clr_proxy?.should.be.false?
+    end
+
+    describe "when asked to stub a method" do
+
+      it "should create an expectation" do
+        nm = "What's in a name"
+        expectation = @isolator.when_told_to(:name) do |cl|
+          cl.return(nm)
+        end
+        expectation.method_name.should.equal :name
+        expectation.has_return_value?.should.be.true?
+        expectation.return_value.should.equal nm
+      end
+    end
+
+  end
+
+  describe 'when verifying if a call was made' do
+
+    before do
+      @rec = Caricature::MethodCallRecorder.new
+      @rec.record_call :my_method
+      @rec.record_call :my_method, 1, 2, 3
+      @proxy = Caricature::RecordingProxy.new(Soldier, @rec)
+    end
+
+    it "should be successful with any arguments allowed" do
+      iso = Caricature::Isolation.new(@proxy, @rec)
+      iso.was_told_to?(:my_method).should.be.true?
+    end
+
+    it "should be successful with a correct set of arguments provided for my_method" do
+      iso = Caricature::Isolation.new(@proxy, @rec)
+      iso.was_told_to?(:my_method){ |ver| ver.with(1, 2, 3) }.should.be.true?
+    end
+
+    it "should be unsuccessful when a wrong set of arguments is provided" do
+      iso = Caricature::Isolation.new(@proxy, @rec)
+      iso.was_told_to?(:my_method){|ver| ver.with(1, 3, 6) }.should.be.false?
+    end
+
+    it "should be unsuccessful when the wrong method name is provided" do
+      iso = Caricature::Isolation.new(@proxy, @rec)
+      iso.was_told_to?(:some_method).should.be.false?
+    end
+
+  end
+
+  describe "when creating an isolation for CLR objects" do
+
+    it "should not raise" do
+      lambda { Caricature::Isolation.for(ClrModels::Ninja) }.should.not.raise
+    end
+
+  end
+
+  describe "after creation of the isolation for a CLR object" do
+
+    before do
+      @isolator = Caricature::Isolation.for(ClrModels::Ninja)
+    end
+
+    it "should create a proxy" do
+      @isolator.proxy.should.not.be == nil
+    end
+
+    it "should create the CLR objects proxy" do
+      @isolator.proxy.is_clr_proxy?.should.be.true?
+    end
+
+  end
+
+end

data/spec/method_call_spec.rb

@@ -0,0 +1,295 @@
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "MethodCallRecorder" do
+
+  before do
+    @recorder = Caricature::MethodCallRecorder.new
+  end
+
+  describe "when recording a call without arguments" do
+
+    before do
+      @recorder.record_call :my_method
+    end
+
+    it "should have 1 method call" do
+      @recorder.method_calls.size.should.equal 1
+    end
+
+    describe "recorded call" do
+
+      before do
+        @mc = @recorder.method_calls[:my_method]
+      end
+
+      it "should have a method call collected" do
+        @mc.should.not.equal nil
+      end
+
+      it "should have the correct name" do
+        @mc.method_name.should.equal :my_method
+      end
+
+      it "should have no arguments" do
+        @mc.args.should.equal [Caricature::ArgumentRecording.new]
+      end
+
+      it "should have no block" do
+         @mc.block.should.equal nil
+      end
+
+      it "should have a count a 1" do
+        @mc.count.should.equal 1
+      end
+
+    end
+
+    end
+
+  describe "when recording a call without arguments but with a block" do
+
+    before do
+      @block_content = "I'm in the block"
+      @recorder.record_call :my_method do
+        @block_content
+      end
+    end
+
+    it "should have 1 method call" do
+      @recorder.method_calls.size.should.equal 1
+    end
+
+    describe "recorded call" do
+
+      before do
+        @mc = @recorder.method_calls[:my_method]
+      end
+
+      it "should have a method call collected" do
+        @mc.should.not.equal nil
+      end
+
+      it "should have the correct name" do
+        @mc.method_name.should.equal :my_method
+      end
+
+      it "should have no arguments" do
+        @mc.args.should.equal [Caricature::ArgumentRecording.new]
+      end
+
+      it "should have a block" do
+         @mc.args.first.block.should.not.equal nil
+      end
+
+      it "should have the correct block" do
+        @mc.args.first.block.call.should.equal @block_content
+      end
+
+      it "should have a count a 1" do
+        @mc.count.should.equal 1
+      end
+
+    end
+
+  end
+
+  describe "when recording a call 1 argument" do
+
+    before do
+      @recorder.record_call :my_method, 1
+    end
+
+    it "should have 1 method call" do
+      @recorder.method_calls.size.should.equal 1
+    end
+
+    describe "recorded call" do
+
+      before do
+        @mc = @recorder.method_calls[:my_method]
+      end
+
+      it "should have a method call collected" do
+        @mc.should.not.equal nil
+      end
+
+      it "should have the correct name" do
+        @mc.method_name.should.equal :my_method
+      end
+
+      it "should have 1 argument" do
+        @mc.args.size.should.equal 1
+      end
+
+      it "should have the correct argument" do
+        @mc.args.should.equal [Caricature::ArgumentRecording.new([1])]
+      end
+
+      it "should have no block" do
+         @mc.block.should.equal nil
+      end
+
+      it "should have a count a 1" do
+        @mc.count.should.equal 1
+      end
+
+    end
+
+  end
+
+  describe "when recording a call 2 arguments" do
+
+    before do
+      @recorder.record_call :my_method, 1, 2
+    end
+
+    it "should have 1 method call" do
+      @recorder.method_calls.size.should.equal 1
+    end
+
+    describe "recorded call" do
+
+      before do
+        @mc = @recorder.method_calls[:my_method]
+      end
+
+      it "should have a method call collected" do
+        @mc.should.not.equal nil
+      end
+
+      it "should have the correct name" do
+        @mc.method_name.should.equal :my_method
+      end
+
+      it "should have 1 argument recording" do
+        @mc.args.size.should.equal 1
+      end
+
+      it "should have the correct arguments" do
+        @mc.args.should.equal [Caricature::ArgumentRecording.new([1, 2])]
+      end
+
+      it "should have no block" do
+         @mc.block.should.equal nil
+      end
+
+      it "should have a count a 1" do
+        @mc.count.should.equal 1
+      end
+
+    end
+
+  end
+
+  describe "when recording 2 calls with no arguments" do
+
+    before do
+      @recorder.record_call :my_method
+      @recorder.record_call :my_method
+    end
+
+    it "should have 1 method call" do
+      @recorder.method_calls.size.should.equal 1
+    end
+
+    describe "recorded call" do
+
+      before do
+        @mc = @recorder.method_calls[:my_method]
+      end
+
+      it "should have a method call collected" do
+        @mc.should.not.equal nil
+      end
+
+      it "should have the correct name" do
+        @mc.method_name.should.equal :my_method
+      end
+
+      it "should have no arguments" do
+        @mc.args.should.equal [Caricature::ArgumentRecording.new]
+      end
+
+      it "should have no block" do
+         @mc.block.should.equal nil
+      end
+
+      it "should have a count a 1" do
+        @mc.count.should.equal 2
+      end
+
+    end
+
+  end
+
+  describe "when recording 2 calls with different arguments" do
+
+    before do
+      @recorder.record_call :my_method
+      @recorder.record_call :my_method, 1, 3, 4
+    end
+
+    it "should have 1 method call" do
+      @recorder.method_calls.size.should.equal 1
+    end
+
+    describe "recorded call" do
+
+      before do
+        @mc = @recorder.method_calls[:my_method]
+      end
+
+      it "should have a method call collected" do
+        @mc.should.not.equal nil
+      end
+
+      it "should have the correct name" do
+        @mc.method_name.should.equal :my_method
+      end
+
+      it "should have argument variations" do
+        @mc.has_argument_variations?.should.be.true?
+      end
+
+      it "should have no block" do
+         @mc.block.should.equal nil
+      end
+
+      it "should have a count a 1" do
+        @mc.count.should.equal 2
+      end
+
+    end
+
+  end
+
+  describe "when asked if a certain method was called" do
+
+    before do
+      @recorder.record_call :my_method
+      @recorder.record_call :my_method, 1, 3, 4
+    end
+
+    it "should confirm when we don't care about the arguments" do
+      @recorder.was_called?(:my_method, :any).should.be.true?
+    end
+
+    it "should confirm when there are no argument variations" do
+      @recorder.record_call :another_method
+      @recorder.was_called?(:another_method, :any).should.be.true?
+    end
+
+    it "should be negative when we provide the wrong arguments" do
+      @recorder.was_called?(:my_method, 1, 2, 5).should.be.false?
+    end
+
+    it "should be positive when we provide the correct arguments" do
+      @recorder.was_called?(:my_method, 1, 3, 4).should.be.true?
+    end
+
+    it "should be positive when we provide no arguments and a call had been recorded without arguments" do
+      @recorder.was_called?(:my_method).should.be.true?
+    end
+  end
+
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,206 @@
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "Caricature::RecordingProxy" do
+
+  before do    
+    @subj = Soldier.new
+    @recorder = Caricature::MethodCallRecorder.new
+    @proxy = Caricature::RecordingProxy.new(@subj, @recorder)
+  end
+
+  it "should forward existing methods" do
+    @proxy.name.should.equal @subj.name
+  end
+
+  it "should call to_s on the proxied object" do
+    @proxy.to_s.should.equal @subj.to_s
+  end
+
+  describe "when invoking a method" do
+
+    before do
+      @proxy.name
+    end
+
+    it "should record a call" do
+      @recorder.size.should.equal 1
+    end
+
+    it "should record the correct call" do
+      mc = @recorder[:name]
+      mc.method_name.should.equal :name
+      mc.args.should.equal [Caricature::ArgumentRecording.new]
+      mc.block.should.equal nil
+    end
+
+  end
+end
+
+describe "Caricature::RecordingClrProxy" do
+
+  describe "for an instance of a CLR class" do
+
+    before do
+      @samurai = ClrModels::Samurai.new
+      @samurai.name = "Nakiro"
+      @recorder = Caricature::MethodCallRecorder.new
+      @proxy = Caricature::RecordingClrProxy.new(@samurai, @recorder)
+    end
+
+    it "should create a proxy" do
+
+      @proxy.name.should.equal @samurai.name
+      @proxy.id.should.equal 0
+    end
+
+    describe "when invoking a method" do
+
+      before do
+        @proxy.name
+      end
+
+      it "should record a call" do
+        @recorder.size.should.equal 1
+      end
+
+      it "should record the correct call" do
+        mc = @recorder[:name]
+        mc.method_name.should.equal :name
+        mc.args.should.equal [Caricature::ArgumentRecording.new]
+        mc.block.should.equal nil
+      end
+
+    end
+
+  end
+
+  describe "for a CLR class" do
+
+    before do
+      @recorder = Caricature::MethodCallRecorder.new
+      @proxy = Caricature::RecordingClrProxy.new(ClrModels::Ninja, @recorder)
+    end
+
+    it "should create a proxy" do
+      @proxy.___subject___.class.should.equal ClrModels::Ninja
+      @proxy.id.should.equal 0
+    end
+
+
+    describe "when invoking a method" do
+
+      before do
+        @proxy.name
+      end
+
+      it "should record a call" do
+        @recorder.size.should.equal 1
+      end
+
+      it "should record the correct call" do
+        mc = @recorder[:name]
+        mc.method_name.should.equal :name
+        mc.args.should.equal [Caricature::ArgumentRecording.new]
+        mc.block.should.equal nil
+      end
+
+    end
+  end
+
+  describe "for a CLR interface" do
+
+    before do
+      @recorder = Caricature::MethodCallRecorder.new
+      @proxy = Caricature::RecordingClrProxy.new(ClrModels::IWarrior, @recorder)
+    end
+
+    it "should create a proxy" do
+      @proxy.class.to_s.should.match /^IWarrior/
+    end
+
+    it "should create a method on the proxy" do
+      @proxy.should.respond_to?(:is_killed_by)
+    end
+
+    it "should create a getter for a property on the proxy" do
+      @proxy.should.respond_to?(:id)
+    end
+
+    it "should create a setter for a writable property on the proxy" do
+      @proxy.should.respond_to?(:name=)
+    end
+
+    describe "when invoking a method" do
+
+      before do
+        @proxy.name
+      end
+
+      it "should record a call" do
+        @recorder.size.should.equal 1
+      end
+
+      it "should record the correct call" do
+        mc = @recorder[:name]
+        mc.method_name.should.equal :name
+        mc.args.should.equal [Caricature::ArgumentRecording.new]
+        mc.block.should.equal nil
+      end
+
+    end
+
+  end
+
+  describe "for a CLR Interface with an event" do
+
+    before do
+      @recorder = Caricature::MethodCallRecorder.new
+      @proxy = Caricature::RecordingClrProxy.new(ClrModels::IExposing, @recorder)
+    end
+
+    it "should create an add method for the event" do
+      @proxy.should.respond_to?(:add_is_exposed_changed)
+    end
+
+    it "should create a remove method for the event" do
+      @proxy.should.respond_to?(:remove_is_exposed_changed)
+    end
+
+  end
+
+  describe "for CLR interface recursion" do
+
+    before do
+      @proxy = Caricature::RecordingClrProxy.new(ClrModels::IExposingWarrior, Caricature::MethodCallRecorder.new)
+    end
+
+    it "should create a method defined on the CLR interface" do
+      @proxy.should.respond_to?(:own_method)
+    end
+
+    it "should create a method defined on one of the composing interfaces" do
+      @proxy.should.respond_to?(:some_method)
+    end
+
+    it "should create a method defined on one of the topmost composing interfaces" do
+      @proxy.should.respond_to?(:is_killed_by)
+    end
+
+    it "should create an add method for an event defined on a composing interface" do
+      @proxy.should.respond_to?(:add_is_exposed_changed)
+    end
+
+    it "should create a remove method for an event defined on a composing interface" do
+      @proxy.should.respond_to?(:remove_is_exposed_changed)
+    end
+
+    it "should create a getter for a property on the proxy" do
+      @proxy.should.respond_to?(:id)
+    end
+
+    it "should create a setter for a writable property on the proxy" do
+      @proxy.should.respond_to?(:name=)
+    end
+  end
+
+end

data/spec/verification_spec.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + "/bacon_helper"
+
+describe "Caricature::Verification" do
+
+  describe "Matching" do
+
+    before do
+      @rec = Caricature::MethodCallRecorder.new
+      @ver = Caricature::Verification.new(:my_method, @rec)
+    end
+
+    describe "Default initialisation" do
+
+      it "should allow any arguments" do
+        @ver.any_args?.should.be.true?
+      end
+
+      it "should match the provided method name when no arguments have been given" do
+        @ver.matches?(:my_method).should.be.true?
+      end
+
+      it "should match the method name when arguments have been given" do
+        @ver.matches?(:my_method, 1, 3, 4).should.be.true?
+      end
+
+    end
+
+    describe "when initialized with and constrained by arguments" do
+
+      before do
+        @ver.with(1, 3, 6)
+      end
+
+      it "should match the provided method name when the correct arguments are given" do
+        @ver.matches?(:my_method, 1, 3, 6).should.be.true?
+      end
+
+      it "should not match the method name when the arguments are not correct" do
+        @ver.matches?(:my_method, 1, 3, 3).should.be.false?
+      end
+
+      it "should not match the method name when no arguments have been given" do
+        @ver.matches?(:my_method).should.be.false?
+      end
+
+    end
+
+    describe "when initialized with and not constrained by arguments" do
+
+      before do
+        @ver.with(1, 3, 6).allow_any_arguments
+      end
+
+      it "should match the provided method name when the correct arguments are given" do
+        @ver.matches?(:my_method, 1, 3, 6).should.be.true?
+      end
+
+      it "should match the method name when the arguments are not correct" do
+        @ver.matches?(:my_method, 1, 3, 3).should.be.true?
+      end
+
+      it "should match the method name when no arguments have been given" do
+        @ver.matches?(:my_method).should.be.true?
+      end
+
+    end
+    
+  end
+
+  describe "Verifying" do
+
+    before do
+      @rec = Caricature::MethodCallRecorder.new
+      @rec.record_call :my_method
+      @rec.record_call :my_method, 1, 2, 3
+      @rec.record_call :another_method
+
+    end
+
+    it "should be successful with any arguments allowed" do
+      ver = Caricature::Verification.new(:my_method, @rec)
+      ver.should.be.successful
+    end
+
+    it "should be successful with a correct set of arguments provided for my_method" do
+      ver = Caricature::Verification.new(:my_method, @rec)
+      ver.with 1, 2, 3
+      ver.should.be.successful
+    end
+
+    it "should be unsuccessful when a wrong set of arguments is provided" do
+      ver = Caricature::Verification.new(:my_method, @rec)
+      ver.with 1, 5, 7
+      ver.should.not.be.successful
+    end
+
+    it "should be unsuccessful when the wrong method name is provided" do
+      ver = Caricature::Verification.new(:some_method, @rec)
+      ver.should.not.be.successful
+    end
+
+  end
+  
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: casualjim-caricature
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ivan Porto Carrero
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Caricature - Bringing simple mocking to the DLR
+email: ivan@flanders.co.nz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- README.markdown
+files: 
+- README
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/casualjim/caricature
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: caricature
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Caricature - Bringing simple mocking to the DLR
+test_files: 
+- spec/bacon_helper.rb
+- spec/core_ext_spec.rb
+- spec/expectation_spec.rb
+- spec/interop_spec.rb
+- spec/isolator_spec.rb
+- spec/method_call_spec.rb
+- spec/proxy_spec.rb
+- spec/verification_spec.rb