fakes 1.1.4 → 1.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8441cd15f6f7f9ce06a62e3ea07f8be22bd185b
+  data.tar.gz: e62db5cbbb80694e4bc1f726ffb7ab8993081b7e
+SHA512:
+  metadata.gz: dc46b7bc3f7a00f8cd364566f8459dce3f2c8d56cc1cadeb574cfe51d9c51bac648cd939902016349298ea36dc922bb38177c224d34e6b9e7036ad2e27c3e226
+  data.tar.gz: 8512462e38329c2dbafafdd9a15fbe8469642d424de49705e2c43480fac3b93f4391e48b3cb5275d3b0bce657a2ec495e0a8dfff3a3b086141d93d7226476637

data/Gemfile

@@ -1,3 +1,3 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gemspec

data/fakes.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "rspec"
+  s.add_runtime_dependency('rspec', "~> 2.14.1")
   s.add_development_dependency "rake"
   s.add_development_dependency "guard"
   s.add_development_dependency "guard-rspec"

data/lib/fakes/arg_behaviour.rb

@@ -1,6 +1,7 @@
 module Fakes
   module ArgBehaviour
     attr_accessor :return_value,:times_called,:arg_matcher
+    attr_reader :callback_block
 
     def initialize_matcher_using(args)
       @arg_matcher = ArgMatchFactory.create_arg_matcher_using(args)
@@ -15,10 +16,15 @@ module Fakes
     end
 
     def capture_args(args)
+      @arguments_provided = true
       @times_called += 1
       @called_args = args
     end
 
+    def run(&callback_block)
+      @callback_block = callback_block
+    end
+
     def matches?(args)
       return @arg_matcher.matches?(args)
     end
@@ -28,9 +34,11 @@ module Fakes
     end
 
     def process
-      return @return_value unless @exception
-      if @exception
-        raise @exception
+      if callback_block
+        @arguments_provided ? callback_block.call(*@called_args) : callback_block.call
+      else
+        raise @exception if @exception
+        @return_value 
       end
     end
   end

data/lib/fakes/version.rb

@@ -1,3 +1,3 @@
 module Fakes
-  VERSION = "1.1.4"
+  VERSION = "1.1.5"
 end

data/spec/spec_helper.rb

@@ -17,3 +17,9 @@ module RSpec
     end
   end
 end
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |c|
+    c.syntax = :should
+  end
+end

data/spec/specs/arg_behaviour_spec.rb

@@ -13,25 +13,46 @@ module Fakes
     before (:each) do
       sut.send(:extend,ArgBehaviour)
     end
+
     context "when continuing its execution" do
-      context "and no exception has been specified to be thrown" do
-        before (:each) do
-          sut.and_return(2)
+      context 'and it has not been given a block to return' do
+        context "and no exception has been specified to be thrown" do
+          before (:each) do
+            sut.and_return(2)
+          end
+          it "should store the return value to be returned during invocation" do
+            expect(sut.process()).to eql(2)
+          end
         end
-        it "should store the return value to be returned during invocation" do
-          sut.process().should == 2
+        context "and an exception has been specified to be thrown" do
+          let(:exception){Exception.new}
+          before (:each) do
+            sut.throws(exception)
+          end
+          it "should throw the exception" do
+            begin
+              sut.process()
+            rescue Exception => e
+              expect(e).to eql(exception)
+            end
+          end
         end
       end
-      context "and an exception has been specified to be thrown" do
-        let(:exception){Exception.new}
-        before (:each) do
-          sut.throws(exception)
-        end
-        it "should throw the exception" do
-          begin
-            sut.process()
-          rescue Exception => e
-            e.should == exception
+
+      context 'and it has been given a block to return' do
+        context "and no exception has been specified to be thrown" do
+          let(:name) { 'JP' }
+
+          before (:each) do
+            sut.capture_args([name])
+            sut.run do |the_name|
+              expect(the_name).to eql(name)
+              2
+            end
+          end
+
+          it "should invoke the block with the arguments passed in, and return the value" do
+            expect(sut.process).to eql(2)
           end
         end
       end
@@ -42,13 +63,13 @@ module Fakes
         sut.capture_args(2)
       end
       it "should increment the number of times it was called" do
-        sut.times_called.should == 1
+        expect(sut.times_called).to eql(1)
       end
       it "should store the arguments it was called with" do
-        sut.called_args.should == 2
+        expect(sut.called_args).to eql(2)
       end
     end
-    
+
     context "when matching a set of arguments" do
       let(:matcher){Object.new}
       before (:each) do
@@ -58,8 +79,8 @@ module Fakes
         matcher.stub(:matches?).with(3).and_return(false)
       end
       it "should match if its argument matcher matches the argument set" do
-        sut.matches?(2).should be_true
-        sut.matches?(3).should be_false
+        expect(sut.matches?(2)).to be_true
+        expect(sut.matches?(3)).to be_false
       end
     end
 
@@ -71,13 +92,13 @@ module Fakes
         ArgMatchFactory.stub(:create_arg_matcher_using).with(2).and_return(the_matcher)
         the_matcher.stub(:matches?).with(2).and_return(true)
       end
-      
+
       before (:each) do
         sut.called_args = 2
       end
 
       it "should make the decision by using the matcher created to match the arguments" do
-        sut.was_called_with?(2).should be_true
+        expect(sut.was_called_with?(2)).to be_true
       end
     end
   end

data/spec/specs/arg_match_factory_spec.rb

@@ -9,9 +9,10 @@ module Fakes
         end
         
         it "should create a combined matcher that is composed of regular matchers" do
-          @result.all_matchers.count.should == 3
+          expect(@result.all_matchers.count).to eql(3)
+          
           @result.all_matchers.each do|matcher|
-            matcher.class.should == RegularArgMatcher
+            expect(matcher.class).to eql(RegularArgMatcher)
           end
         end
       end
@@ -26,8 +27,8 @@ module Fakes
         end
         
         it "should create a combined matcher that only using the matchers provided" do
-          @result.all_matchers.count.should == 1
-          @result.all_matchers[0].should == matcher
+          expect(@result.all_matchers.count).to eql(1)
+          expect(@result.all_matchers[0]).to eql(matcher)
         end
       end
     end

data/spec/specs/arg_matching_scenarios_spec.rb

@@ -7,7 +7,7 @@ module Fakes
 
       fake.hello("World")
 
-      fake.received(:hello).called_with(ArgumentMatching.any).should_not be_nil
+      expect(fake.received(:hello).called_with(ArgumentMatching.any)).to_not be_nil
     end
 
     it "should be able to intercept using greater than matchers" do
@@ -15,7 +15,7 @@ module Fakes
 
       fake.hello(10)
 
-      fake.received(:hello).called_with(ArgumentMatching.greater_than(2)).should_not be_nil
+      expect(fake.received(:hello).called_with(ArgumentMatching.greater_than(2))).to_not be_nil
     end
 
     it "should be able to intercept using regex matchers" do
@@ -23,7 +23,7 @@ module Fakes
 
       fake.hello("This is cool")
 
-      fake.received(:hello).called_with(ArgumentMatching.regex(/is/)).should_not be_nil
+      expect(fake.received(:hello).called_with(ArgumentMatching.regex(/is/))).to_not be_nil
     end
 
     it "should be able to intercept using range matchers" do
@@ -31,7 +31,7 @@ module Fakes
 
       fake.hello(7)
 
-      fake.received(:hello).called_with(ArgumentMatching.in_range(4..8)).should_not be_nil
+      expect(fake.received(:hello).called_with(ArgumentMatching.in_range(4..8))).to_not be_nil
     end
 
     it "should be able to intercept using conditional matchers" do
@@ -39,7 +39,7 @@ module Fakes
 
       fake.hello(7)
 
-      fake.received(:hello).called_with(ArgumentMatching.condition{|item| item < 10}).should_not be_nil
+      expect(fake.received(:hello).called_with(ArgumentMatching.condition{|item| item < 10})).to_not be_nil
     end
 
     it "should be able to intercept by mixing regular arguments with matchers" do
@@ -47,10 +47,10 @@ module Fakes
 
       fake.hello(7,4,"Yes")
 
-      fake.received(:hello).called_with(7,ArgumentMatching.greater_than(2),ArgumentMatching.regex(/Y/)).should_not be_nil
-      fake.received(:hello).called_with(7,ArgumentMatching.any,ArgumentMatching.regex(/Y/)).should_not be_nil
-      fake.received(:hello).called_with(7,ArgumentMatching.any,"Yes").should_not be_nil
-      fake.received(:hello).called_with(6,ArgumentMatching.any,"Yes").should be_nil
+      expect(fake.received(:hello).called_with(7,ArgumentMatching.greater_than(2),ArgumentMatching.regex(/Y/))).to_not be_nil
+      expect(fake.received(:hello).called_with(7,ArgumentMatching.any,ArgumentMatching.regex(/Y/))).to_not be_nil
+      expect(fake.received(:hello).called_with(7,ArgumentMatching.any,"Yes")).to_not be_nil
+      expect(fake.received(:hello).called_with(6,ArgumentMatching.any,"Yes")).to be_nil
     end
   end
 

data/spec/specs/arg_set_spec.rb

@@ -7,7 +7,7 @@ module Fakes
 
       
       it "should initialize required members" do
-        sut.times_called.should == 0
+        expect(sut.times_called).to eql(0)
       end
 
     end

data/spec/specs/argument_matching_spec.rb

@@ -2,41 +2,41 @@ module Fakes
   describe ArgumentMatching do
     context "when creating matchers" do
       it "should be able to create a matcher that matches anything" do
-        (1..10).each{|item| ArgumentMatching.any.matches?(item).should be_true}
+        (1..10).each{|item| expect(ArgumentMatching.any.matches?(item)).to be_true}
       end
       it "should be able to create a numeric greater than matcher" do
         match = ArgumentMatching.greater_than(5)
-        match.matches?(4).should be_false
-        match.matches?(5).should be_false
-        match.matches?(6).should be_true
+        expect(match.matches?(4)).to be_false
+        expect(match.matches?(5)).to be_false
+        expect(match.matches?(6)).to be_true
         
       end
       it "should be able to create a range matcher" do
         match = ArgumentMatching.in_range((1..10))
-        match.matches?(4).should be_true
-        match.matches?(10).should be_true
-        match.matches?(11).should be_false
+        expect(match.matches?(4)).to be_true
+        expect(match.matches?(10)).to be_true
+        expect(match.matches?(11)).to be_false
       end
       it "should be able to create a nil matcher" do
         match = ArgumentMatching.nil
-        match.matches?(nil).should be_true
-        match.matches?(10).should be_false
+        expect(match.matches?(nil)).to be_true
+        expect(match.matches?(10)).to be_false
       end
       it "should be able to create a not nil matcher" do
         match = ArgumentMatching.not_nil
-        match.matches?(10).should be_true
-        match.matches?(nil).should be_false
+        expect(match.matches?(10)).to be_true
+        expect(match.matches?(nil)).to be_false
       end
       it "should be able to create a regex string matcher" do
         match = ArgumentMatching.regex(/a|e|i|o|u/)
-        match.matches?("awwef").should be_true
-        match.matches?("rwwgf").should be_false
+        expect(match.matches?("awwef")).to be_true
+        expect(match.matches?("rwwgf")).to be_false
       end
 
       it "should be able to create a lambda based matcher" do
         match = ArgumentMatching.condition{|item| item > 3}
-        match.matches?(2).should be_false
-        match.matches?(7).should be_true
+        expect(match.matches?(2)).to be_false
+        expect(match.matches?(7)).to be_true
       end
     end
     

data/spec/specs/block_arg_matcher_spec.rb

@@ -6,7 +6,7 @@ module Fakes
       let(:sut){BlockArgMatcher.new(lambda{|item| true})}
       
       it "should decide by using its provided block" do
-        sut.matches?(2).should be_true
+        expect(sut.matches?(2)).to be_true
       end
     end
   end

data/spec/specs/class_swap_spec.rb

@@ -8,7 +8,7 @@ module Fakes
       let(:sut){ClassSwap.new(MyClass,Object.new)}
 
       it "should store the symbol of the class it is going to replace" do
-        sut.klass.should == :MyClass
+        expect(sut.klass).to eql(:MyClass)
       end
     end
     context "when initiated" do
@@ -30,11 +30,11 @@ module Fakes
       end
       
       it "should remove the current value of the class constant and store it for reset at a later point" do
-        @klass_to_remove.should == the_sym
+        expect(@klass_to_remove).to eql(the_sym)
       end
       it "should replace the current value of the symbol with the replacement value" do
-        @klass_to_change.should == the_sym
-        @replacement_value.should == replacement
+        expect(@klass_to_change).to eql(the_sym)
+        expect(@replacement_value).to eql(replacement)
       end
     end
     context "when reset" do
@@ -64,9 +64,9 @@ module Fakes
       end
       
       it "should switch the value of the class back to its original value" do
-        @klass_to_remove.should == the_sym
-        @klass_to_change.should == the_sym
-        @replacement_value.should == MyClass
+        expect(@klass_to_remove).to eql(the_sym)
+        expect(@klass_to_change).to eql(the_sym)
+        expect(@replacement_value).to eql(MyClass)
       end
     end
   end

data/spec/specs/class_swaps_spec.rb

@@ -43,11 +43,11 @@ module Fakes
         end
 
         it 'should add a new class swap to the set of class swaps' do
-          ClassSwaps.instance.swaps[the_sym].should == the_swap
+          expect(ClassSwaps.instance.swaps[the_sym]).to eql(the_swap)
         end
 
         it "should initiate the swap" do
-          the_swap.inititated.should be_true
+          expect(the_swap.inititated).to be_true
         end
         
 
@@ -67,7 +67,7 @@ module Fakes
         end
 
         it 'should throw an error indicating that the swap is already present' do
-          @exception.message.should contain(MyClass.to_s)
+          expect(@exception.message).to contain(MyClass.to_s)
         end
       end
     end
@@ -86,11 +86,11 @@ module Fakes
       end
 
       it 'should reset each of the swaps' do
-        first_swap.was_reset.should be_true
-        second_swap.was_reset.should be_true
+        expect(first_swap.was_reset).to be_true
+        expect(second_swap.was_reset).to be_true
       end
       it "should clear the swaps" do
-        sut.swaps.count.should == 0
+        expect(sut.swaps.count).to eql(0)
       end
     end
     context "Integration Test" do
@@ -98,21 +98,21 @@ module Fakes
       
       it 'should be able to swap class values' do
         ClassSwaps.instance.add_fake_for(Dir,replacement)
-        Dir.should == replacement
+        expect(Dir).to eql(replacement)
         ClassSwaps.instance.reset
-        Dir.should_not == replacement
+        expect(Dir).to_not eql(replacement)
       end
 
       it 'should be able to swap class values in another module' do
         ClassSwaps.instance.add_fake_for(SomeModule::ClassInAModule,replacement)
-        SomeModule::ClassInAModule.should == replacement
+        expect(SomeModule::ClassInAModule).to eql(replacement)
         ClassSwaps.instance.reset
-        SomeModule::ClassInAModule.should_not == replacement
+        expect(SomeModule::ClassInAModule).to_not eql(replacement)
 
         ClassSwaps.instance.add_fake_for(SomeModule::NestedModule::AClassInANestedModule,replacement)
-        SomeModule::NestedModule::AClassInANestedModule.should == replacement
+        expect(SomeModule::NestedModule::AClassInANestedModule).to eql(replacement)
         ClassSwaps.instance.reset
-        SomeModule::NestedModule::AClassInANestedModule.should_not == replacement
+        expect(SomeModule::NestedModule::AClassInANestedModule).to_not eql(replacement)
       end
     end
   end

data/spec/specs/combined_arg_matcher_spec.rb

@@ -21,7 +21,7 @@ module Fakes
       
       
       it "should match if each of its argument matchers matches its respective argument" do
-        @result.should be_true
+        expect(@result).to be_true
       end
     end
     context "when adding a matcher" do
@@ -36,7 +36,7 @@ module Fakes
       
       
       it "should add the matcher to its set of matchers" do
-        matchers[0].should == first_matcher
+        expect(matchers[0]).to eql(first_matcher)
       end
     end
   end

data/spec/specs/extensions_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe Fakes do
   it "should be able to create a new fake" do
-    fake.class.should == Fakes::Fake 
+    expect(fake.class).to eql(Fakes::Fake )
   end
   it "should be able to create a new fake and specify return values for methods" do
     item = fake :hello => 'World', :age => 33
-    item.hello.should == 'World'
-    item.age.should == 33
+    expect(item.hello).to eql('World')
+    expect(item.age).to eql(33)
   end
 
   context "when specifying a fake for a class" do
@@ -20,11 +20,11 @@ describe Fakes do
     end
     
     it "should register a new fake with the class swaps" do
-      swaps.received(:add_fake_for).called_with(Dir,arg_match.not_nil).should_not be_nil
+      expect(swaps.received(:add_fake_for).called_with(Dir,arg_match.not_nil)).to_not be_nil
     end
 
     it "should return the newly created fake" do
-      @result.should_not be_nil
+      expect(@result).to_not be_nil
     end
   end
   context "when faking a class and specifying return values" do
@@ -35,7 +35,7 @@ describe Fakes do
       reset_fake_classes
     end
     it "should replace the class with the fake return to return the values specified" do
-      Dir.exist?('hello').should be_true
+      expect(Dir.exist?('hello')).to be_true
     end
   end
   

data/spec/specs/fake_spec.rb

@@ -16,10 +16,10 @@ module Fakes
           @result = sut.stub(symbol)
         end
         it "should add a new method stub to the list of all invocations" do
-          invocations[symbol].should == new_method
+          expect(invocations[symbol]).to eql(new_method)
         end
         it "should return the method invocation to continue specifying call behaviour" do
-          @result.should == new_method 
+          expect(@result).to eql(new_method )
         end
       end
 
@@ -32,11 +32,11 @@ module Fakes
         end
 
         it "should not readd the method to the list of invocations" do
-          invocations.count.should == 1
+          expect(invocations.count).to eql(1)
         end
 
         it "should return the method invocation to continue specifying call behaviour" do
-          @result.should == new_method 
+          expect(@result).to eql(new_method )
         end
       end
     end
@@ -53,7 +53,7 @@ module Fakes
         @result = sut.received(symbol)
       end
       it "should return the method invocation for the called method" do
-        @result.should == method_invocation 
+        expect(@result).to eql(method_invocation )
       end
     end
     context "when verifying whether a call was never received" do
@@ -70,7 +70,7 @@ module Fakes
 
       it "should base its decision on the list of received invocations" do
         [:other, existing].each do|item|
-          sut.never_received?(item).should_not be_equal(invocations.has_key?(item))
+          expect(sut.never_received?(item)).to_not be_equal(invocations.has_key?(item))
         end
       end
     end
@@ -104,10 +104,10 @@ module Fakes
           @result = sut.hello(args)
         end
         it "should trigger the invocation with the arguments" do
-          invocation.args.should == [args]
+          expect(invocation.args).to eql([args])
         end
         it "should return the result of triggering the invocation" do
-          @result.should == invocation.return_value
+          expect(@result).to eql(invocation.return_value)
         end
       end
       context "and the method is for an invocation that was not prepared" do
@@ -118,19 +118,19 @@ module Fakes
           @result = sut.hello(args)
         end
         it "should add a new invocation which ignores arguments to the list of all invocations" do
-          invocations.has_key?(:hello).should be_true
+          expect(invocations.has_key?(:hello)).to be_true
         end
 
         it "should configure the new invocation to ignore all arguments" do
-          invocation.ignores_args.should be_true 
+          expect(invocation.ignores_args).to be_true
         end
 
         it "should invoke the invocation with the arguments" do
-          invocation.args.should == [args]
+          expect(invocation.args).to eql([args])
         end
 
         it "should return the result of triggering the new invocation" do
-          @result.should == invocation.return_value
+          expect(@result).to eql(invocation.return_value)
         end
       end
     end
@@ -165,10 +165,10 @@ module Fakes
           @result = sut.send(:hello,args)
         end
         it "should trigger the invocation with the arguments" do
-          invocation.args.should == [args]
+          expect(invocation.args).to eql([args])
         end
         it "should return the result of triggering the invocation" do
-          @result.should == invocation.return_value
+          expect(@result).to eql(invocation.return_value)
         end
       end
       context "and the method is for an invocation that was not prepared" do
@@ -179,19 +179,19 @@ module Fakes
           @result = sut.send(:hello,args)
         end
         it "should add a new invocation which ignores arguments to the list of all invocations" do
-          invocations.has_key?(:hello).should be_true
+          expect(invocations.has_key?(:hello)).to be_true
         end
 
         it "should configure the new invocation to ignore all arguments" do
-          invocation.ignores_args.should be_true 
+          expect(invocation.ignores_args).to be_true
         end
 
         it "should invoke the invocation with the arguments" do
-          invocation.args.should == [args]
+          expect(invocation.args).to eql([args])
         end
 
         it "should return the result of triggering the new invocation" do
-          @result.should == invocation.return_value
+          expect(@result).to eql(invocation.return_value)
         end
       end
     end
@@ -202,103 +202,103 @@ module Fakes
           fake = Fake.new
 
           fake.stub(:hello).with(ArgumentMatching.regex(/W/)).and_return("Hello World") 
-          fake.hello("World").should == "Hello World"
+          expect(fake.hello("World")).to eql("Hello World")
         end
         it "should be able to intercept on methods using combinations of explicit values and matchers" do
           fake = Fake.new
 
           fake.stub(:hello).with(ArgumentMatching.regex(/W/),ArgumentMatching.greater_than(3),10).and_return("Hello World") 
 
-          fake.hello("World",4,10).should == "Hello World"
-          fake.hello("World",2,10).should == nil
+          expect(fake.hello("World",4,10)).to eql("Hello World")
+          expect(fake.hello("World",2,10)).to be_nil
         end
       end
       context "setting up return values" do
         it "should be able to intercept on methods that take a singular value" do
           fake = Fake.new
           fake.stub(:hello).with("World").and_return("Hello World") 
-          fake.hello("World").should == "Hello World"
+          expect(fake.hello("World")).to eql("Hello World")
         end
 
         it "should be able to intercept on methods that take a hash" do
           fake = Fake.new
           fake.stub(:hello).with(:id => "JP",:age => 33).and_return("Hello World") 
-          fake.hello(:id => "JP",:age => 33).should == "Hello World"
+          expect(fake.hello(:id => "JP",:age => 33)).to eql("Hello World")
         end
 
         it "should be able to intercept on methods that take a value and a hash" do
           fake = Fake.new
           fake.stub(:hello).with(1,:id => "JP",:age => 33).and_return("Hello World") 
 
-          fake.hello(1,:id => "JP",:age => 33).should == "Hello World"
-          fake.hello(2,:id => "JP",:age => 33).should be_nil
+          expect(fake.hello(1,:id => "JP",:age => 33)).to eql("Hello World")
+          expect(fake.hello(2,:id => "JP",:age => 33)).to be_nil
         end
 
         it "should be able to intercept on methods that take an array" do
           fake = Fake.new
           fake.stub(:hello).with([1,2,3,4]).and_return("Hello World") 
 
-          fake.hello([1,2,3,4]).should == "Hello World"
+          expect(fake.hello([1,2,3,4])).to eql("Hello World")
         end
 
         it "should be able to intercept on methods that take an value, and an array" do
           fake = Fake.new
           fake.stub(:hello).with(1,[1,2,3,4]).and_return("Hello World") 
 
-          fake.hello(1,[1,2,3,4]).should == "Hello World"
+          expect(fake.hello(1,[1,2,3,4])).to eql("Hello World")
         end
       end
       context "verifying calls were made" do
         it "should be able to intercept on methods that take a singular value" do
           fake = Fake.new
           fake.hello("World")
-          fake.received(:hello).called_with("World").should be_true
+          expect(fake.received(:hello).called_with("World")).to be_true
         end
 
         it "should be able to intercept on methods that have no arguments" do
           fake = Fake.new
           fake.hello
-          fake.received(:hello).should_not be_nil
+          expect(fake.received(:hello)).to_not be_nil
         end
 
 
         it "should be able to intercept on methods that take a hash" do
           fake = Fake.new
           fake.hello(:id => "JP",:age => 33)
-          fake.received(:hello).called_with(:id => "JP",:age => 33).should_not be_nil
-          fake.received(:hello).called_with(:id => "JS",:age => 33).should be_nil
+          expect(fake.received(:hello).called_with(:id => "JP",:age => 33)).to_not be_nil
+          expect(fake.received(:hello).called_with(:id => "JS",:age => 33)).to be_nil
         end
 
         it "should be able to intercept on methods that take a value and a hash" do
           fake = Fake.new
 
           fake.hello(1,:id => "JP",:age => 33)
-          fake.received(:hello).called_with(1,:id => "JP",:age => 33).should_not be_nil
-          fake.received(:hello).called_with(1,:id => "JS",:age => 33).should be_nil
+          expect(fake.received(:hello).called_with(1,:id => "JP",:age => 33)).to_not be_nil
+          expect(fake.received(:hello).called_with(1,:id => "JS",:age => 33)).to be_nil
         end
 
         it "should be able to intercept on methods that take an array" do
           fake = Fake.new
 
           fake.hello([1,2,3,4])
-          fake.received(:hello).called_with([1,2,3,4]).should_not be_nil
-          fake.received(:hello).called_with([1,2,3,5]).should be_nil
+          expect(fake.received(:hello).called_with([1,2,3,4])).to_not be_nil
+          expect(fake.received(:hello).called_with([1,2,3,5])).to be_nil
         end
 
         it "should be able to intercept on methods that take an value, and an array" do
           fake = Fake.new
           fake.hello(1,[1,2,3,4])
 
-          fake.received(:hello).called_with(1,[1,2,3,4]).should_not be_nil
-          fake.received(:hello).called_with(1,[1,2,3,5]).should be_nil
+          expect(fake.received(:hello).called_with(1,[1,2,3,4])).to_not be_nil
+          expect(fake.received(:hello).called_with(1,[1,2,3,5])).to be_nil
         end
 
         it 'should be able to determine if it received a method call' do
           fake = Fake.new
           fake.hello(1,[1,2,3,4])
             
-          fake.received?(:hello,1,[1,2,3,4]).should be_true
-          fake.received?(:hello).should be_true
+          expect(fake.received?(:hello,1,[1,2,3,4])).to be_true
+          expect(fake.received?(:hello)).to be_true
         end
         
 

data/spec/specs/ignore_set_spec.rb

@@ -6,14 +6,14 @@ module Fakes
 
     context "when created" do
       it "should initialize required members" do
-        sut.times_called.should == 0
+        expect(sut.times_called).to eql(0)
       end
     end
 
     context "when matching an argument set" do
       it "should match any argument set" do
-        sut.matches?([1,2,3,4]).should be_true
-        sut.matches?([3,"hello",4,5]).should be_true
+        expect(sut.matches?([1,2,3,4])).to be_true
+        expect(sut.matches?([3,"hello",4,5])).to be_true
       end
     end
 
@@ -23,7 +23,7 @@ module Fakes
         sut.capture_args(2)
       end
       it "should store a list for each set of arguments" do
-        sut.arg_sets.count.should == 2
+        expect(sut.arg_sets.count).to eql(2)
       end
     end
 
@@ -42,7 +42,7 @@ module Fakes
       end
 
       it "should make the decision by using the matcher created to match the argument sets that were stored" do
-        sut.was_called_with?(2).should be_true
+        expect(sut.was_called_with?(2)).to be_true
       end
     end
   end

data/spec/specs/method_stub_spec.rb

@@ -16,10 +16,10 @@ module Fakes
         @result = sut.with(args)
       end
       it "should add a new argument set to its list of arguments" do
-        arg_sets[0].should == argument_set
+        expect(arg_sets[0]).to eql(argument_set)
       end
       it "should return the argument set to continue specifying behaviour" do
-        @result.should == argument_set
+        expect(@result).to eql(argument_set)
       end
     end
 
@@ -35,10 +35,10 @@ module Fakes
         @result = sut.ignore_arg
       end
       it "should add the ignored set to the list of argument sets" do
-        arg_sets[0].should == ignored_set
+        expect(arg_sets[0]).to eql(ignored_set)
       end
       it "should return the ignored set to specify other behaviour" do
-        @result.should == ignored_set
+        expect(@result).to eql(ignored_set)
       end
     end
 
@@ -64,10 +64,10 @@ module Fakes
         sut.throws(exception)
       end
       it "should add the ignored set to the set of args sets" do
-        arg_sets[0].should == ignored_set
+        expect(arg_sets[0]).to eql(ignored_set)
       end
       it "should have stored the exception on the new argument set" do
-        ignored_set.exception.should == exception
+        expect(ignored_set.exception).to eql(exception)
       end
     end
     context "when invoked with a set of arguments" do
@@ -92,10 +92,10 @@ module Fakes
           @result = sut.invoke(arguments)
         end
         it "should tell the argument set to capture the arguments it was called with" do
-          arg_set.args.should == [arguments]
+          expect(arg_set.args).to eql([arguments])
         end
         it "should return using from the arg set" do
-          @result.should == 2
+          expect(@result).to eql(2)
         end
 
       end
@@ -110,10 +110,10 @@ module Fakes
           @result = sut.invoke(arguments)
         end
         it "should tell the argument set to capture the arguments it was called with" do
-          arg_set.args.should == [arguments]
+          expect(arg_set.args).to eql([arguments])
         end
         it "should return using from the missing arg set" do
-          @result.should == 2
+          expect(@result).to eql(2)
         end
       end
 
@@ -142,7 +142,7 @@ module Fakes
         end
 
         it "should return the argument set that was called with the arguments" do
-          @result.should == arg_set
+          expect(@result).to eql(arg_set)
         end
       end
       context "and none of its argument sets were called with the arguments" do
@@ -150,7 +150,7 @@ module Fakes
           @result = sut.called_with(arguments)
         end
         it "should return nil" do
-          @result.should be_nil
+          expect(@result).to be_nil
         end
       end
 
@@ -170,7 +170,7 @@ module Fakes
       end
 
       it "it should return the sum of the invocations of its argument sets" do
-        sut.total_times_called.should == 5
+        expect(sut.total_times_called).to eql(5)
       end
     end
     context "when verifying whether it was called a certain number of times" do
@@ -187,8 +187,8 @@ module Fakes
       end
 
       it "it should return whether the sum of its argset invocations is the same as the number of request made" do
-        sut.times?(5).should be_true
-        sut.times?(3).should be_false
+        expect(sut.times?(5)).to be_true
+        expect(sut.times?(3)).to be_false
       end
     end
   end

data/spec/specs/regular_arg_matcher_spec.rb

@@ -6,8 +6,8 @@ module Fakes
       let(:sut){RegularArgMatcher.new(2)}
       
       it "should match if the incoming value matches the value it was created to match" do
-        sut.matches?(2).should be_true
-        sut.matches?(3).should be_false
+        expect(sut.matches?(2)).to be_true
+        expect(sut.matches?(3)).to be_false
       end
     end
   end

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: fakes
 version: !ruby/object:Gem::Version
-  version: 1.1.4
-  prerelease: 
+  version: 1.1.5
 platform: ruby
 authors:
 - Develop With Passion®
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2014-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 2.14.1
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Faking library that allows inspection of received calls after they have
@@ -83,7 +74,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -122,27 +113,26 @@ files:
 - spec/specs/regular_arg_matcher_spec.rb
 homepage: http://www.developwithpassion.com
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: fakes
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple faking library
 test_files:
 - spec/spec_helper.rb