caricature 0.3.0 → 0.3.1

data/README.markdown

@@ -13,12 +13,12 @@ An Isolation will create what in Rhino.Mocks would be called a DynamicMock (but
 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 an isolation 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.
+To specify a stub/expectation on an isolation you have one and only one way of doing that with the method called when_receiving.
+Then only if you're interested in asserting if a method has been called you can use the did_receive? method for this.
 
 <pre>
 isolation = Isolation.for(Ninja)
-isolation.when_told_to(:attack) do |exp|
+isolation.when_receiving(:attack) do |exp|
   exp.with(:shuriken)
   exp.return(3)
 end
@@ -26,7 +26,7 @@ end
 Battle.new(mock)
 battle.combat
 
-isolation.was_told_to?(:attack).should.be.true?
+isolation.did_receive?(:attack).should.be.true?
 </pre>
 
 It may be very important to note that when you're going to be isolating CLR classes to be used in other CLR classes

data/spec/bacon_helper.rb

@@ -12,6 +12,10 @@ load_assembly 'ClrModels'
 
 class Soldier
 
+  def initialize
+    @life = 10
+  end
+
   def name
     "Tommy Boy"
   end
@@ -20,6 +24,31 @@ class Soldier
     "I'm a soldier"
   end
 
+  def attack(target, weapon)
+    weapon.attack(target)
+  end
+
+  def is_killed_by?(weapon)
+    weapon.damage > 3
+  end
+
+  def survive_attack_with(weapon)
+    @life - weapon.damage
+  end
+
+end
+
+class Dagger
+
+  def damage
+    2
+  end
+
+  def attack(target)
+    target.survive_attack_with self  
+  end
+
+
 end
 
 module Caricature

data/spec/integration_spec.rb

@@ -2,139 +2,631 @@ require File.dirname(__FILE__) + "/bacon_helper"
 
 describe "Full scenarios" do
 
-  describe "when isolating CLR interfaces" do
-    before do
-      @ninja = ClrModels::Ninja.new      
-      @weapon = Caricature::Isolation.for(ClrModels::IWeapon)
-    end
+  describe "CLR to CLR interactions" do
+
+    describe "when isolating CLR interfaces" do
+      before do
+        @ninja = ClrModels::Ninja.new
+        @weapon = Caricature::Isolation.for(ClrModels::IWeapon)
+      end
 
-    it "should work without expectations" do
-      @ninja.attack ClrModels::Ninja.new, @weapon
+      it "should work without expectations" do
+        @ninja.attack ClrModels::Ninja.new, @weapon
 
-      @weapon.was_told_to?(:attack).should.be.successful
-    end
+        @weapon.did_receive?(:attack).should.be.successful
+      end
+
+      it "should work for expectations with an argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @weapon.when_receiving(:attack).with(ninja).return(5)
+
+        @ninja.attack(ninja, @weapon).should.equal 5
+
+        @weapon.did_receive?(:attack).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @weapon.when_receiving(:attack).with(ClrModels::Ninja.new).return(5)
+
+        @ninja.attack(ClrModels::Ninja.new, @weapon).should.equal 0
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @weapon.when_receiving(:attack).with(ninja).return(5)
+
+        @ninja.attack(ninja, @weapon).should.equal 5
+
+        @weapon.did_receive?(:attack).with(ninja).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @weapon.when_receiving(:attack).with(ninja).return(5)
+
+        @ninja.attack(ninja, @weapon).should.equal 5
+
+        @weapon.did_receive?(:attack).with(ClrModels::Ninja.new).should.not.be.successful
+      end
+
+      it "should work with an expectation with any arguments" do
+        @weapon.when_receiving(:damage).return(5)
+
+        @ninja.is_killed_by(@weapon).should.be.true?
+        @weapon.did_receive?(:damage).should.be.successful
+      end
 
-    it "should work with an expectation with any arguments" do
-      @weapon.when_told_to(:damage).return(5)
+      it "should work with an expectation getting different method call result" do
+        @weapon.when_receiving(:damage).return(2)
+
+        @ninja.is_killed_by(@weapon).should.be.false?
+        @weapon.did_receive?(:damage).should.be.successful
+      end
+
+      it "should work for an assertion on a specific argument" do
+        @weapon.when_receiving(:damage).return(2)
+
+        @ninja.is_killed_by(@weapon).should.be.false?
+        @weapon.did_receive?(:damage).should.be.successful
+      end
 
-      @ninja.is_killed_by(@weapon).should.be.true?
-      @weapon.was_told_to?(:damage).should.be.successful
     end
 
-#    it "should work with an expectation with any arguments" do
-#      @weapon.when_told_to(:damage).return(5)
-#
-#      @ninja.is_killed_by(@weapon).should.be.true?
-#      @weapon.was_told_to?(:damage).should.be.successful
-#    end
+    describe "when isolating CLR classes" do
+
+      before do
+        @weapon = ClrModels::Sword.new
+        @ninja = Caricature::Isolation.for(ClrModels::Ninja)
+      end
 
-    it "should work with an expectation getting different method call result" do
-      @weapon.when_told_to(:damage).return(2)
+      it "should work without expectations" do
+        result = @weapon.attack @ninja
+        result.should.equal 0
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+      it "should work for expectations with an argument constraint" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(ClrModels::Ninja.new).should.equal 6
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.not.be.successful
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(ClrModels::Sword.new).should.not.be.successful
+      end
+
+      it "should work with an expectation for any arguments" do
+        @ninja.when_receiving(:survive_attack_with).return(5)
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+      it "should work with an assertion for specific arguments" do
+        @ninja.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+      it "should fail for an assertion with wrong arguments" do
+        @ninja.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.
+          did_receive?(:survive_attack_with).
+          with(Caricature::Isolation.for(ClrModels::IWeapon)).
+          should.not.be.successful
+      end
 
-      @ninja.is_killed_by(@weapon).should.be.false?
-      @weapon.was_told_to?(:damage).should.be.successful
     end
 
-    it "should work for an assertion on a specific argument" do
-      @weapon.when_told_to(:damage).return(2)
+    describe "when isolating CLR instances" do
+
+      before do
+        @weapon = ClrModels::Sword.new
+        @ninja = Caricature::Isolation.for(ClrModels::Ninja.new)
+      end
+
+      it "should work without expectations" do
+        result = @weapon.attack @ninja
+        result.should.equal 0
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+      it "should work for expectations with an argument constraint" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(ClrModels::Ninja.new).should.equal 6
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.not.be.successful
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(ClrModels::Sword.new).should.not.be.successful
+      end
+
+      it "should work with an expectation for any arguments" do
+        @ninja.when_receiving(:survive_attack_with).return(5)
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+      it "should fail for an assertion for specific arguments" do
+        @ninja.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+        var = @ninja.did_receive?(:survive_attack_with).with(:any)
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+      it "should allow to delegate the method call to the real instance (partial mock)" do
+        @ninja.when_receiving(:survive_attack_with).super_after
+
+        result = @weapon.attack @ninja
+        result.should.equal 6
+
+        @ninja.did_receive?(:survive_attack_with).should.be.successful
+      end
 
-      @ninja.is_killed_by(@weapon).should.be.false?
-      @weapon.was_told_to?(:damage).should.be.successful
     end
 
   end
 
-  describe "when isolating CLR classes" do
+  describe "CLR isolations for ruby objects" do
 
-    before do
-      @weapon = ClrModels::Sword.new
-      @ninja = Caricature::Isolation.for(ClrModels::Ninja)
-    end
+    describe "when isolating CLR interfaces" do
+      before do
+        @soldier = Soldier.new
+        @weapon = Caricature::Isolation.for(ClrModels::IWeapon)
+      end
 
-    it "should work without expectations" do
-      result = @weapon.attack @ninja
-      result.should.equal 0
+      it "should work without expectations" do
+        @soldier.attack Soldier.new, @weapon
 
-      @ninja.was_told_to?(:survive_attack_with).with(@weapon).should.be.successful
-    end
+        @weapon.did_receive?(:attack).should.be.successful
+      end
+
+      it "should work for expectations with an argument constraint" do
+        soldier = Soldier.new
+        @weapon.when_receiving(:attack).with(soldier).return(5)
+
+        @soldier.attack(soldier, @weapon).should.equal 5
+
+        @weapon.did_receive?(:attack).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @weapon.when_receiving(:attack).with(Soldier.new).return(5)
+
+        @soldier.attack(Soldier.new, @weapon).should.equal 0
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        soldier = Soldier.new
+        @weapon.when_receiving(:attack).with(soldier).return(5)
+
+        @soldier.attack(soldier, @weapon).should.equal 5
+
+        @weapon.did_receive?(:attack).with(soldier).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        soldier = Soldier.new
+        @weapon.when_receiving(:attack).with(soldier).return(5)
+
+        @soldier.attack(soldier, @weapon).should.equal 5
+
+        @weapon.did_receive?(:attack).with(Soldier.new).should.not.be.successful
+      end
+
+      it "should work with an expectation with any arguments" do
+        @weapon.when_receiving(:damage).return(5)
+
+        @soldier.is_killed_by?(@weapon).should.be.true?
+        @weapon.did_receive?(:damage).should.be.successful
+      end
+
+      it "should work with an expectation getting different method call result" do
+        @weapon.when_receiving(:damage).return(2)
+
+        @soldier.is_killed_by?(@weapon).should.be.false?
+        @weapon.did_receive?(:damage).should.be.successful
+      end
 
-    it "should work with an expectation for any arguments" do
-      @ninja.when_told_to(:survive_attack_with).return(5)
+      it "should work for an assertion on a specific argument" do
+        @weapon.when_receiving(:damage).return(2)
 
-      result = @weapon.attack @ninja
-      result.should.equal 5
+        @soldier.is_killed_by?(@weapon).should.be.false?
+        @weapon.did_receive?(:damage).should.be.successful
+      end
 
-      @ninja.was_told_to?(:survive_attack_with).with(:any).should.be.successful
     end
 
-    it "should work with an assertion for specific arguments" do
-      @ninja.when_told_to(:survive_attack_with) do |method_should|
-         method_should.return(5)
+    describe "when isolating CLR classes" do
+
+      before do
+        @weapon = Dagger.new
+        @ninja = Caricature::Isolation.for(ClrModels::Ninja)
+      end
+
+      it "should work without expectations" do
+        result = @weapon.attack @ninja
+        result.should.equal 0
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+      it "should work for expectations with an argument constraint" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(Soldier.new).should.equal 8
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.not.be.successful
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(Dagger.new).should.not.be.successful
       end
 
-      result = @weapon.attack @ninja
-      result.should.equal 5
+      it "should work with an expectation for any arguments" do
+        @ninja.when_receiving(:survive_attack_with).return(5)
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+      it "should work with an assertion for specific arguments" do
+        @ninja.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+      it "should fail for an assertion with wrong arguments" do
+        @ninja.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.
+          did_receive?(:survive_attack_with).
+          with(Caricature::Isolation.for(ClrModels::IWeapon)).
+          should.not.be.successful
+      end
 
-      @ninja.was_told_to?(:survive_attack_with).with(@weapon).should.be.successful
     end
 
-    it "should fail for an assertion with wrong arguments" do
-      @ninja.when_told_to(:survive_attack_with) do |method_should|
-         method_should.return(5)
+    describe "when isolating CLR instances" do
+
+      before do
+        @weapon = Dagger.new
+        @ninja = Caricature::Isolation.for(ClrModels::Ninja.new)
+      end
+
+      it "should work without expectations" do
+        result = @weapon.attack @ninja
+        result.should.equal 0
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
       end
 
-      result = @weapon.attack @ninja
-      result.should.equal 5
+      it "should work for expectations with an argument constraint" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(Soldier.new).should.equal 8
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.not.be.successful
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        ninja = ClrModels::Ninja.new
+        @ninja.when_receiving(:survive_attack_with).with(@weapon).return(5)
+
+        @weapon.attack(@ninja).should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(Dagger.new).should.not.be.successful
+      end
+
+      it "should work with an expectation for any arguments" do
+        @ninja.when_receiving(:survive_attack_with).return(5)
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+
+        @ninja.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+      it "should fail for an assertion for specific arguments" do
+        @ninja.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @weapon.attack @ninja
+        result.should.equal 5
+        var = @ninja.did_receive?(:survive_attack_with).with(:any)
+        @ninja.did_receive?(:survive_attack_with).with(@weapon).should.be.successful
+      end
+           
 
-      @ninja.
-        was_told_to?(:survive_attack_with).
-        with(Caricature::Isolation.for(ClrModels::IWeapon)).
-        should.not.be.successful
     end
 
   end
+  
+  describe "Ruby to Ruby interactions" do
 
-  describe "when isolating CLR instances" do
+    describe "when isolating Ruby classes" do
 
-    before do
-      @weapon = ClrModels::Sword.new
-      @ninja = Caricature::Isolation.for(ClrModels::Ninja.new)
-    end
+      before do
+        @dagger = Dagger.new
+        @soldier = Caricature::Isolation.for(Soldier)
+      end
 
-    it "should work without expectations" do
-      result = @weapon.attack @ninja
-      result.should.equal 0
+      it "should work without expectations" do
+        result = @dagger.attack @soldier
+        result.should.equal nil
 
-      @ninja.was_told_to?(:survive_attack_with).with(@weapon).should.be.successful
-    end
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
+      end
 
-    it "should work with an expectation for any arguments" do
-      @ninja.when_told_to(:survive_attack_with).return(5)
+      it "should work for expectations with an argument constraint" do
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
 
-      result = @weapon.attack @ninja
-      result.should.equal 5
+        @dagger.attack(@soldier).should.equal 5
 
-      @ninja.was_told_to?(:survive_attack_with).with(:any).should.be.successful
-    end
+        @soldier.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(Soldier.new).should.equal 8
+
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.not.be.successful
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        soldier = Soldier.new
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(@soldier).should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
+      end
+
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        soldier = Soldier.new
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(@soldier).should.equal 5
 
-    it "should fail for an assertion for specific arguments" do
-      @ninja.when_told_to(:survive_attack_with) do |method_should|
-         method_should.return(5)
+        @soldier.did_receive?(:survive_attack_with).with(Dagger.new).should.not.be.successful
+      end
+
+      it "should work with an expectation for any arguments" do
+        @soldier.when_receiving(:survive_attack_with).return(5)
+
+        result = @dagger.attack @soldier
+        result.should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+      it "should work with an assertion for specific arguments" do
+        @soldier.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @dagger.attack @soldier
+        result.should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
+      end
+
+      it "should fail for an assertion with wrong arguments" do
+        @soldier.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @dagger.attack @soldier
+        result.should.equal 5
+
+        @soldier.
+          did_receive?(:survive_attack_with).
+          with(Caricature::Isolation.for(Dagger)).
+          should.not.be.successful
       end
 
-      result = @weapon.attack @ninja
-      result.should.equal 5
-      var = @ninja.was_told_to?(:survive_attack_with).with(:any)
-      @ninja.was_told_to?(:survive_attack_with).with(@weapon).should.be.successful
     end
 
-    it "should allow to delegate the method call to the real instance (partial mock)" do
-      @ninja.when_told_to(:survive_attack_with).super_after
+    describe "when isolating Ruby instances" do
+
+      before do
+        @dagger = Dagger.new
+        @soldier = Caricature::Isolation.for(Soldier.new)
+      end
+
+      it "should work without expectations" do
+        result = @dagger.attack @soldier
+        result.should.equal nil
+
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
+      end
+
+      it "should work for expectations with an argument constraint" do
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(@soldier).should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+       it "should work for expectations with an argument constraint when a wrong argument is passed in" do
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(Soldier.new).should.equal 8
+
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.not.be.successful
+      end
+
+      it "should work for expectations with an argument constraint and an assertion argument constraint" do
+        soldier = Soldier.new
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(@soldier).should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
+      end
 
-      result = @weapon.attack @ninja
-      result.should.equal 6
+       it "should fail for expectations with an argument constraint and an assertion argument constraint" do
+        soldier = Soldier.new
+        @soldier.when_receiving(:survive_attack_with).with(@dagger).return(5)
+
+        @dagger.attack(@soldier).should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(Dagger.new).should.not.be.successful
+      end
+
+      it "should work with an expectation for any arguments" do
+        @soldier.when_receiving(:survive_attack_with).return(5)
+
+        result = @dagger.attack @soldier
+        result.should.equal 5
+
+        @soldier.did_receive?(:survive_attack_with).with(:any).should.be.successful
+      end
+
+      it "should fail for an assertion for specific arguments" do
+        @soldier.when_receiving(:survive_attack_with) do |method_should|
+           method_should.return(5)
+        end
+
+        result = @dagger.attack @soldier
+        result.should.equal 5
+        var = @soldier.did_receive?(:survive_attack_with).with(:any)
+        @soldier.did_receive?(:survive_attack_with).with(@dagger).should.be.successful
+      end
+
+      it "should allow to delegate the method call to the real instance (partial mock)" do
+        @soldier.when_receiving(:survive_attack_with).super_after
+
+        result = @dagger.attack @soldier
+        result.should.equal 8
+
+        @soldier.did_receive?(:survive_attack_with).should.be.successful
+      end
 
-      @ninja.was_told_to?(:survive_attack_with).should.be.successful
     end
 
   end

data/spec/isolation_spec.rb

@@ -66,7 +66,7 @@ describe "Caricature::Isolation" do
 
       it "should create an expectation with a block" do
         nm = "What's in a name"
-        expectation = @isolator.when_told_to(:name) do |cl|
+        expectation = @isolator.when_receiving(:name) do |cl|
           cl.return(nm)
         end
         expectation.method_name.should.equal :name
@@ -76,7 +76,7 @@ describe "Caricature::Isolation" do
 
       it "should create an expectation without a block" do
         nm = "What's in a name"
-        expectation = @isolator.when_told_to(:name).return(nm)
+        expectation = @isolator.when_receiving(:name).return(nm)
         expectation.method_name.should.equal :name
         expectation.has_return_value?.should.be.true?
         expectation.return_value.should.equal nm
@@ -107,7 +107,7 @@ describe "Caricature::Isolation" do
 
       it "should create an expectation with a block" do
         nm = "What's in a name"
-        expectation = @isolator.when_told_to(:name) do |cl|
+        expectation = @isolator.when_receiving(:name) do |cl|
           cl.return(nm)
         end
         expectation.method_name.should.equal :name
@@ -117,7 +117,7 @@ describe "Caricature::Isolation" do
 
       it "should create an expectation without a block" do
         nm = "What's in a name"
-        expectation = @isolator.when_told_to(:name).return(nm)
+        expectation = @isolator.when_receiving(:name).return(nm)
         expectation.method_name.should.equal :name
         expectation.has_return_value?.should.be.true?
         expectation.return_value.should.equal nm

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: caricature
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Ivan Porto Carrero
@@ -9,21 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-15 00:00:00 +02:00
+date: 2009-05-16 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
-description: Caricature - Bringing simple mocking to the DLR
+description: 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.
 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

data/README

@@ -1,29 +0,0 @@
-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 isolate 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 isolations is the one that JP Boodhoo proposed WhenToldTo and WasToldTo.
-To specify a stub/expectation on an isolation 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.
-
-
-isolation = Isolation.for(Ninja)
-isolation.when_told_to(:attack) do |exp|
-  exp.with(:shuriken)
-  exp.return(3)
-end
-
-Battle.new(isolation)
-battle.combat
-
-isolation.was_told_to?(:attack).should.be.true?