rspec-mocks 2.12.1 → 2.12.2

data/spec/rspec/mocks/any_number_of_times_spec.rb

@@ -24,7 +24,7 @@ describe "AnyNumberOfTimes" do
   it "returns the mocked value when called after a similar stub" do
     @mock.stub(:message).and_return :stub_value
     @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
-    @mock.message.should eq :mock_value
-    @mock.message.should eq :mock_value
+    expect(@mock.message).to eq :mock_value
+    expect(@mock.message).to eq :mock_value
   end
 end

data/spec/rspec/mocks/argument_expectation_spec.rb

@@ -9,7 +9,7 @@ module RSpec
         obj = double("matcher")
         obj.stub(:respond_to?).with(:matches?).and_return(true)
         obj.stub(:respond_to?).with(:failure_message_for_should).and_return(true)
-        argument_expectation.send(:is_matcher?, obj).should be_true
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_true
       end
 
       it "considers an object that responds to #matches? and #failure_message to be a matcher for backward compatibility" do
@@ -18,7 +18,7 @@ module RSpec
         obj.stub(:respond_to?).with(:matches?).and_return(true)
         obj.stub(:respond_to?).with(:failure_message_for_should).and_return(false)
         obj.stub(:respond_to?).with(:failure_message).and_return(true)
-        argument_expectation.send(:is_matcher?, obj).should be_true
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_true
       end
 
       it "does NOT consider an object that only responds to #matches? to be a matcher" do
@@ -27,7 +27,7 @@ module RSpec
         obj.stub(:respond_to?).with(:matches?).and_return(true)
         obj.stub(:respond_to?).with(:failure_message_for_should).and_return(false)
         obj.stub(:respond_to?).with(:failure_message).and_return(false)
-        argument_expectation.send(:is_matcher?, obj).should be_false
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_false
       end
     end
   end

data/spec/rspec/mocks/at_least_spec.rb

@@ -7,9 +7,9 @@ module RSpec
 
       it "fails if method is never called" do
         @double.should_receive(:do_something).at_least(4).times
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails when called less than n times" do
@@ -17,31 +17,31 @@ module RSpec
         @double.do_something
         @double.do_something
         @double.do_something
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails when at least once method is never called" do
         @double.should_receive(:do_something).at_least(:once)
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails when at least twice method is called once" do
         @double.should_receive(:do_something).at_least(:twice)
         @double.do_something
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails when at least twice method is never called" do
         @double.should_receive(:do_something).at_least(:twice)
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "passes when at least n times method is called exactly n times" do
@@ -93,7 +93,7 @@ module RSpec
 
       it "returns the value given by a block when the at least once method is called" do
         @double.should_receive(:to_s).at_least(:once) { "testing" }
-        @double.to_s.should eq "testing"
+        expect(@double.to_s).to eq "testing"
         @double.rspec_verify
       end
 
@@ -127,15 +127,15 @@ module RSpec
       it "uses a stub value if no value set" do
         @double.stub(:do_something => 'foo')
         @double.should_receive(:do_something).at_least(:once)
-        @double.do_something.should eq 'foo'
-        @double.do_something.should eq 'foo'
+        expect(@double.do_something).to eq 'foo'
+        expect(@double.do_something).to eq 'foo'
       end
 
       it "prefers its own return value over a stub" do
         @double.stub(:do_something => 'foo')
         @double.should_receive(:do_something).at_least(:once).and_return('bar')
-        @double.do_something.should eq 'bar'
-        @double.do_something.should eq 'bar'
+        expect(@double.do_something).to eq 'bar'
+        expect(@double.do_something).to eq 'bar'
       end
     end
   end

data/spec/rspec/mocks/at_most_spec.rb

@@ -56,7 +56,7 @@ module RSpec
 
       it "returns the value given by a block when at_most(:once) method is called" do
         @double.should_receive(:to_s).at_most(:once) { "testing" }
-        @double.to_s.should eq "testing"
+        expect(@double.to_s).to eq "testing"
         @double.rspec_verify
       end
 
@@ -64,26 +64,26 @@ module RSpec
         @double.should_receive(:do_something).at_most(2).times
         @double.do_something
         @double.do_something
-        lambda do
+        expect {
           @double.do_something
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails fast when at_most(:once) and is called twice" do
         @double.should_receive(:do_something).at_most(:once)
         @double.do_something
-        lambda do
+        expect {
           @double.do_something
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails fast when at_most(:twice) and is called three times" do
         @double.should_receive(:do_something).at_most(:twice)
         @double.do_something
         @double.do_something
-        lambda do
+        expect {
           @double.do_something
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/block_return_value_spec.rb

@@ -5,7 +5,7 @@ describe "a double declaration with a block handed to:" do
     it "returns the value of executing the block" do
       obj = Object.new
       obj.should_receive(:foo) { 'bar' }
-      obj.foo.should eq('bar')
+      expect(obj.foo).to eq('bar')
     end
 
     it "works when a multi-return stub has already been set" do
@@ -13,7 +13,7 @@ describe "a double declaration with a block handed to:" do
       return_value = Object.new
       obj.stub(:foo).and_return(return_value, nil)
       obj.should_receive(:foo) { return_value }
-      obj.foo.should be(return_value)
+      expect(obj.foo).to be(return_value)
     end
   end
 
@@ -21,7 +21,7 @@ describe "a double declaration with a block handed to:" do
     it "returns the value of executing the block" do
       obj = Object.new
       obj.stub(:foo) { 'bar' }
-      obj.foo.should eq('bar')
+      expect(obj.foo).to eq('bar')
     end
   end
 
@@ -29,7 +29,7 @@ describe "a double declaration with a block handed to:" do
     it "returns the value of executing the block" do
       obj = Object.new
       obj.stub(:foo).with('baz') { 'bar' }
-      obj.foo('baz').should eq('bar')
+      expect(obj.foo('baz')).to eq('bar')
     end
   end
 
@@ -38,7 +38,7 @@ describe "a double declaration with a block handed to:" do
       it "returns the value of executing the block" do
         obj = Object.new
         obj.stub(:foo).send(method) { 'bar' }
-        obj.foo.should eq('bar')
+        expect(obj.foo).to eq('bar')
       end
     end
   end
@@ -47,7 +47,7 @@ describe "a double declaration with a block handed to:" do
     it "returns the value of executing the block" do
       obj = Object.new
       obj.stub(:foo).at_least(1).times { 'bar' }
-      obj.foo('baz').should eq('bar')
+      expect(obj.foo('baz')).to eq('bar')
     end
   end
 end

data/spec/rspec/mocks/bug_report_10260_spec.rb

@@ -3,6 +3,6 @@ require 'spec_helper'
 describe "An RSpec Mock" do
   it "hides internals in its inspect representation" do
     m = double('cup')
-    m.inspect.should =~ /#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
+    expect(m.inspect).to match /#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
   end
 end

data/spec/rspec/mocks/bug_report_10263_spec.rb

@@ -1,16 +1,18 @@
+require 'spec_helper'
+
 describe "Double" do
   let(:test_double) { double }
 
   specify "when one example has an expectation inside the block passed to should_receive" do
     test_double.should_receive(:msg) do |arg|
-      arg.should be_true #this call exposes the problem
+      expect(arg).to be_true #this call exposes the problem
     end
     begin
       test_double.msg(false)
     rescue Exception
     end
   end
-  
+
   specify "then the next example should behave as expected instead of saying" do
     test_double.should_receive(:foobar)
     test_double.foobar
@@ -18,8 +20,8 @@ describe "Double" do
     begin
       test_double.foobar
     rescue Exception => e
-      e.message.should eq "Double received unexpected message :foobar with (no args)"
+      expect(e.message).to eq "Double received unexpected message :foobar with (no args)"
     end
-  end 
+  end
 end
 

data/spec/rspec/mocks/bug_report_11545_spec.rb

@@ -26,7 +26,7 @@ describe 'should_receive' do
   end
   
   it 'cleans up after itself' do
-    (class << LiarLiarPantsOnFire; self; end).instance_methods.should_not include("something")
+    expect((class << LiarLiarPantsOnFire; self; end).instance_methods).not_to include("something")
   end
 end
 

data/spec/rspec/mocks/bug_report_600_spec.rb

@@ -19,4 +19,4 @@ module BugReport600
       ExampleClass.method_that_uses_define_method
     end
   end
-end
+end

data/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -10,7 +10,7 @@ module Bug7611
     end
 
     it "should" do
-      Bar.new.class.should eq Bar
+      expect(Bar.new.class).to eq Bar
     end 
   end
 end

data/spec/rspec/mocks/bug_report_8165_spec.rb

@@ -16,16 +16,16 @@ describe "An object where respond_to? is true and does not have method" do
     obj = Object.new
     obj.should_receive(:respond_to?).with(:foobar).and_return(true)
     obj.should_receive(:foobar).and_return(:baz)
-    obj.respond_to?(:foobar).should be_true
-    obj.foobar.should eq :baz
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
   end
 
   it "does not raise an exception for mock" do
     obj = double("obj")
     obj.should_receive(:respond_to?).with(:foobar).and_return(true)
     obj.should_receive(:foobar).and_return(:baz)
-    obj.respond_to?(:foobar).should be_true
-    obj.foobar.should eq :baz
+    expect(obj.respond_to?(:foobar)).to be_true
+    expect(obj.foobar).to eq :baz
   end
 
 end

data/spec/rspec/mocks/bug_report_830_spec.rb

@@ -12,9 +12,9 @@ module RSpec
 
       it 'still reports mock failures' do
         Foo.should_not_receive :bar
-        lambda do
+        expect {
           Foo.foo
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/bug_report_957_spec.rb

@@ -11,11 +11,11 @@ module RSpec
       end
 
       it "returns the value for the stub on the base class" do
-        @base_class.find.should eq "stubbed_value"
+        expect(@base_class.find).to eq "stubbed_value"
       end
 
       it "returns the value for the descendent class" do
-        @concrete_class.find.should eq "stubbed_value"
+        expect(@concrete_class.find).to eq "stubbed_value"
       end
     end
   end

data/spec/rspec/mocks/configuration_spec.rb

@@ -12,13 +12,13 @@ module RSpec
       end
 
       it 'adds stub and should_receive to the given modules' do
-        instance_methods_of(mod_1).should_not include(:stub, :should_receive)
-        instance_methods_of(mod_2).should_not include(:stub, :should_receive)
+        expect(instance_methods_of(mod_1)).not_to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).not_to include(:stub, :should_receive)
 
         config.add_stub_and_should_receive_to(mod_1, mod_2)
 
-        instance_methods_of(mod_1).should include(:stub, :should_receive)
-        instance_methods_of(mod_2).should include(:stub, :should_receive)
+        expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
       end
     end
   end

data/spec/rspec/mocks/double_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "double" do
   it "is an alias for stub and mock" do
-    double().should be_a(RSpec::Mocks::Mock)
+    expect(double()).to be_a(RSpec::Mocks::Mock)
   end
   
   it "uses 'Double' in failure messages" do

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -85,7 +85,7 @@ module RSpec
 
       it "fails with block matchers" do
         expect do
-          @double.should_receive(:msg).with {|arg| arg.should eq :received }
+          @double.should_receive(:msg).with {|arg| expect(arg).to eq :received }
           @double.msg :no_msg_for_you
         end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end

data/spec/rspec/mocks/hash_excluding_matcher_spec.rb

@@ -6,59 +6,59 @@ module RSpec
       describe HashExcludingMatcher do
         
         it "describes itself properly" do
-          HashExcludingMatcher.new(:a => 5).description.should eq "hash_not_including(:a=>5)"
+          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
         end      
 
         describe "passing" do
           it "matches a hash without the specified key" do
-            hash_not_including(:c).should eq({:a => 1, :b => 2})
+            expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
           end
           
           it "matches a hash with the specified key, but different value" do
-            hash_not_including(:b => 3).should eq({:a => 1, :b => 2})
+            expect(hash_not_including(:b => 3)).to eq({:a => 1, :b => 2})
           end
                     
           it "matches a hash without the specified key, given as anything()" do
-            hash_not_including(:c => anything).should eq({:a => 1, :b => 2})
+            expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
           end
 
           it "matches an empty hash" do
-            hash_not_including(:a).should eq({})
+            expect(hash_not_including(:a)).to eq({})
           end
           
           it "matches a hash without any of the specified keys" do
-            hash_not_including(:a, :b, :c).should eq({ :d => 7})
+            expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
           end
           
         end
         
         describe "failing" do
           it "does not match a non-hash" do
-            hash_not_including(:a => 1).should_not == 1
+            expect(hash_not_including(:a => 1)).not_to eq 1
           end
           
           it "does not match a hash with a specified key" do
-            hash_not_including(:b).should_not == {:b => 2}
+            expect(hash_not_including(:b)).not_to eq(:b => 2)
           end
           
           it "does not match a hash with the specified key/value pair" do
-            hash_not_including(:b => 2).should_not == {:a => 1, :b => 2}
+            expect(hash_not_including(:b => 2)).not_to eq(:a => 1, :b => 2)
           end
           
           it "does not match a hash with the specified key" do
-            hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2}
+            expect(hash_not_including(:a, :b => 3)).not_to eq(:a => 1, :b => 2)
           end
           
           it "does not match a hash with one of the specified keys" do
-            hash_not_including(:a, :b).should_not == {:b => 2}
+            expect(hash_not_including(:a, :b)).not_to eq(:b => 2)
           end
           
           it "does not match a hash with some of the specified keys" do
-            hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2}
+            expect(hash_not_including(:a, :b, :c)).not_to eq(:a => 1, :b => 2)
           end
           
           it "does not match a hash with one key/value pair included" do
-            hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7}
+            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
           end
         end
       end

data/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -4,84 +4,84 @@ module RSpec
   module Mocks
     module ArgumentMatchers
       describe HashIncludingMatcher do
-        
+
         it "describes itself properly" do
-          HashIncludingMatcher.new(:a => 1).description.should eq "hash_including(:a=>1)"
-        end      
+          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
+        end
 
         describe "passing" do
           it "matches the same hash" do
-            hash_including(:a => 1).should eq({:a => 1})
+            expect(hash_including(:a => 1)).to eq({:a => 1})
           end
 
           it "matches a hash with extra stuff" do
-            hash_including(:a => 1).should eq({:a => 1, :b => 2})
+            expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
           end
-          
+
           describe "when matching against other matchers" do
             it "matches an int against anything()" do
-              hash_including(:a => anything, :b => 2).should eq({:a => 1, :b => 2})
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => 1, :b => 2})
             end
 
             it "matches a string against anything()" do
-              hash_including(:a => anything, :b => 2).should eq({:a => "1", :b => 2})
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => "1", :b => 2})
             end
           end
-          
+
           describe "when passed only keys or keys mixed with key/value pairs" do
             it "matches if the key is present" do
-              hash_including(:a).should eq({:a => 1, :b => 2})
+              expect(hash_including(:a)).to eq({:a => 1, :b => 2})
             end
-            
+
             it "matches if more keys are present" do
-              hash_including(:a, :b).should eq({:a => 1, :b => 2, :c => 3})
+              expect(hash_including(:a, :b)).to eq({:a => 1, :b => 2, :c => 3})
             end
 
             it "matches a string against a given key" do
-              hash_including(:a).should eq({:a => "1", :b => 2})
+              expect(hash_including(:a)).to eq({:a => "1", :b => 2})
             end
 
             it "matches if passed one key and one key/value pair" do
-              hash_including(:a, :b => 2).should eq({:a => 1, :b => 2})
+              expect(hash_including(:a, :b => 2)).to eq({:a => 1, :b => 2})
             end
-            
+
             it "matches if passed many keys and one key/value pair" do
-              hash_including(:a, :b, :c => 3).should eq({:a => 1, :b => 2, :c => 3, :d => 4})
+              expect(hash_including(:a, :b, :c => 3)).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
             end
-            
+
             it "matches if passed many keys and many key/value pairs" do
-              hash_including(:a, :b, :c => 3, :e => 5).should eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
+              expect(hash_including(:a, :b, :c => 3, :e => 5)).to eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
             end
           end
         end
-        
+
         describe "failing" do
           it "does not match a non-hash" do
-            hash_including(:a => 1).should_not == 1
+            expect(hash_including(:a => 1)).not_to eq 1
           end
 
           it "does not match a hash with a missing key" do
-            hash_including(:a => 1).should_not == {:b => 2}
+            expect(hash_including(:a => 1)).not_to eq(:b => 2)
           end
-          
+
           it "does not match a hash with a missing key" do
-            hash_including(:a).should_not == {:b => 2}
+            expect(hash_including(:a)).not_to eq(:b => 2)
           end
-          
+
           it "does not match an empty hash with a given key" do
-            hash_including(:a).should_not == {}
+            expect(hash_including(:a)).not_to eq({})
           end
-          
+
           it "does not match a hash with a missing key when one pair is matching" do
-            hash_including(:a, :b => 2).should_not == {:b => 2}
+            expect(hash_including(:a, :b => 2)).not_to eq(:b => 2)
           end
-          
+
           it "does not match a hash with an incorrect value" do
-            hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
+            expect(hash_including(:a => 1, :b => 2)).not_to eq(:a => 1, :b => 3)
           end
 
           it "does not match when values are nil but keys are different" do
-            hash_including(:a => nil).should_not == {:b => nil}
+            expect(hash_including(:a => nil)).not_to eq(:b => nil)
           end
         end
       end