caricature 0.7.1 → 0.7.2

data/spec/rspec/integration/clr_to_ruby_spec.rb

@@ -0,0 +1,228 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "CLR isolations for ruby objects" do
+
+  describe "when isolating CLR interfaces" do
+    before do
+      @soldier = Soldier.new
+      @weapon = Caricature::Isolation.for(ClrModels::IWeapon)
+    end
+
+    it "should work without expectations" do
+      @soldier.attack Soldier.new, @weapon
+
+      @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 == 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 == 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 == 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 == 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 for an assertion on a specific argument" do
+      @weapon.when_receiving(:damage).return(2)
+
+      @soldier.is_killed_by?(@weapon).should be_false
+      @weapon.did_receive?(:damage).should be_successful
+    end
+
+  end
+
+  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 == 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 == 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 == 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 == 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 == 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 == 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 == 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 == 5
+
+      @ninja.
+              did_receive?(:survive_attack_with).
+              with(Caricature::Isolation.for(ClrModels::IWeapon)).
+              should_not be_successful
+    end
+
+  end
+
+  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 == 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 == 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 == 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 == 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 == 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 == 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 == 5
+      var = @ninja.did_receive?(:survive_attack_with).with(:any)
+      @ninja.did_receive?(:survive_attack_with).with(@weapon).should be_successful
+    end
+
+
+  end
+
+end

data/spec/rspec/integration/indexer_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "CLR to CLR interactions" do
+
+  describe "when isolating CLR classes" do
+
+    describe "that have an indexer" do
+      before do
+        @cons = ClrModels::IndexerCaller.new
+        @ind = Caricature::Isolation.for(ClrModels::IndexerContained)
+      end
+
+      it "should work without expectations" do
+        @cons.call_index_on_class(@ind, "key1").should be_nil
+      end
+
+      it "should work with an expectation" do
+        @ind.when_receiving(:__getitem__).return("5")
+        
+        @cons.call_index_on_class(@ind, "key1").should == "5"
+      end
+
+
+    end
+
+  end
+
+end

data/spec/rspec/integration/ruby_to_ruby_spec.rb

@@ -0,0 +1,272 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe "Ruby to Ruby interactions" do
+
+  describe "when isolating Ruby classes" do
+
+    before do
+      @dagger = Dagger.new
+      @soldier = Caricature::Isolation.for(Soldier)
+    end
+
+    it "should work without expectations" do
+      result = @dagger.attack @soldier
+      result.should == 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 == 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 == 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 == 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 == 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 == 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 == 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 == 5
+
+      @soldier.
+              did_receive?(:survive_attack_with).
+              with(Caricature::Isolation.for(Dagger)).
+              should_not be_successful
+    end
+
+  end
+
+  describe "when isolating Ruby classes with class members" do
+
+    before do
+      @dagger = Dagger.new
+      @soldier = Caricature::Isolation.for(SoldierWithClassMembers)
+    end
+
+    it "should work without expectations" do
+      result = @dagger.attack @soldier
+      result.should == 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 == 5
+
+      @soldier.did_receive?(:survive_attack_with).with(:any).should be_successful
+    end
+
+    it "should work for an expctation on a class method without an argument constraint" do
+      @soldier.when_class_receives(:class_name).return(5)
+
+      @soldier.class.class_name.should == 5
+
+      @soldier.did_class_receive?(:class_name).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 == 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 == 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 == 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 == 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 == 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 == 5
+
+      @soldier.
+              did_receive?(:survive_attack_with).
+              with(Caricature::Isolation.for(Dagger)).
+              should_not be_successful
+    end
+
+  end
+
+  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 == 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 == 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 == 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 == 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 == 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 == 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 == 5
+      var = @soldier.did_receive?(:survive_attack_with).with(:any)
+#      @soldier.did_receive?(:survive_attack_with).with(@dagger).should be_successful
+      @soldier.should have_received(:survive_attack_with).with(@dagger)
+    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 == 8
+
+      @soldier.should have_received(:survive_attack_with)
+    end
+    
+    it "should be able to isolate objects with constructor params" do
+      sheath = Caricature::Isolation.for(Sheath)   
+      sheath.when_receiving(:insert).raise("Overridden")
+      lambda { sheath.insert(@dagger) }.should raise_error(RuntimeError, /Overridden/)
+    end 
+    
+    it "should be able to isolate objects with constructor params" do
+      sheath = Caricature::Isolation.for(Sheath)
+        lambda { sheath.insert(@dagger) }.should_not raise_error
+    end
+
+  end  
+
+end