rspec-mocks 2.12.1 → 2.12.2

data/spec/rspec/mocks/serialization_spec.rb

@@ -87,9 +87,9 @@ module RSpec
 
       without_yaml_loaded do
         it 'does not add #to_yaml to the stubbed object' do
-          serializable_object.should_not respond_to(:to_yaml)
+          expect(serializable_object).not_to respond_to(:to_yaml)
           set_stub
-          serializable_object.should_not respond_to(:to_yaml)
+          expect(serializable_object).not_to respond_to(:to_yaml)
         end
       end
 
@@ -102,7 +102,7 @@ module RSpec
 
         it 'does not interfere with its marshalling' do
           marshalled_copy = Marshal.load(Marshal.dump(serializable_object))
-          marshalled_copy.should eq serializable_object
+          expect(marshalled_copy).to eq serializable_object
         end
       end
     end

data/spec/rspec/mocks/stash_spec.rb

@@ -21,7 +21,7 @@ module RSpec
         klass.rspec_verify
 
         klass.rspec_reset
-        klass.foo(:yeah).should equal(:original_value)
+        expect(klass.foo(:yeah)).to equal(:original_value)
       end
     end
 

data/spec/rspec/mocks/stub_chain_spec.rb

@@ -9,21 +9,21 @@ module RSpec
         context "using and_return" do
           it "returns expected value from chaining only one method call" do
             object.stub_chain(:msg1).and_return(:return_value)
-            object.msg1.should equal(:return_value)
+            expect(object.msg1).to equal(:return_value)
           end
         end
 
         context "using a block" do
           it "returns the correct value" do
             object.stub_chain(:msg1) { :return_value }
-            object.msg1.should equal(:return_value)
+            expect(object.msg1).to equal(:return_value)
           end
         end
 
         context "using a hash" do
           it "returns the value of the key/value pair" do
             object.stub_chain(:msg1 => :return_value)
-            object.msg1.should equal(:return_value)
+            expect(object.msg1).to equal(:return_value)
           end
         end
       end
@@ -32,21 +32,21 @@ module RSpec
         context "using and_return" do
           it "returns expected value from chaining two method calls" do
             object.stub_chain(:msg1, :msg2).and_return(:return_value)
-            object.msg1.msg2.should equal(:return_value)
+            expect(object.msg1.msg2).to equal(:return_value)
           end
         end
 
         context "using a block" do
           it "returns the correct value" do
             object.stub_chain(:msg1, :msg2) { :return_value }
-            object.msg1.msg2.should equal(:return_value)
+            expect(object.msg1.msg2).to equal(:return_value)
           end
         end
 
         context "using a hash" do
           it "returns the value of the key/value pair" do
             object.stub_chain(:msg1, :msg2 => :return_value)
-            object.msg1.msg2.should equal(:return_value)
+            expect(object.msg1.msg2).to equal(:return_value)
           end
         end
       end
@@ -55,35 +55,35 @@ module RSpec
         context "using and_return" do
           it "returns expected value from chaining two method calls" do
             object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
           end
         end
 
         context "using a block" do
           it "returns the correct value" do
             object.stub_chain(:msg1, :msg2, :msg3, :msg4) { :return_value }
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
           end
         end
 
         context "using a hash" do
           it "returns the value of the key/value pair" do
             object.stub_chain(:msg1, :msg2, :msg3, :msg4 => :return_value)
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
           end
         end
 
         context "using a hash with a string key" do
           it "returns the value of the key/value pair" do
             object.stub_chain("msg1.msg2.msg3.msg4" => :return_value)
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
+            expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
           end
         end
       end
 
       it "returns expected value from chaining four method calls" do
         object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
-        object.msg1.msg2.msg3.msg4.should equal(:return_value)
+        expect(object.msg1.msg2.msg3.msg4).to equal(:return_value)
       end
 
       context "with messages shared across multiple chains" do
@@ -93,8 +93,8 @@ module RSpec
               object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
               object.stub_chain(:msg1, :msg2, :msg4).and_return(:second)
 
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg1.msg2.msg4.should equal(:second)
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg1.msg2.msg4).to equal(:second)
             end
           end
 
@@ -103,8 +103,8 @@ module RSpec
               object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
               object.stub_chain(:msg4, :msg2, :msg3).and_return(:second)
 
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg4.msg2.msg3.should equal(:second)
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg4.msg2.msg3).to equal(:second)
             end
           end
         end
@@ -115,8 +115,8 @@ module RSpec
               object.stub_chain(:msg1, :msg2, :msg3 => :first)
               object.stub_chain(:msg1, :msg2, :msg4 => :second)
 
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg1.msg2.msg4.should equal(:second)
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg1.msg2.msg4).to equal(:second)
             end
           end
 
@@ -125,8 +125,8 @@ module RSpec
               object.stub_chain(:msg1, :msg2, :msg3 => :first)
               object.stub_chain(:msg4, :msg2, :msg3 => :second)
 
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg4.msg2.msg3.should equal(:second)
+              expect(object.msg1.msg2.msg3).to equal(:first)
+              expect(object.msg4.msg2.msg3).to equal(:second)
             end
           end
         end
@@ -134,15 +134,15 @@ module RSpec
 
       it "returns expected value when chain is a dot separated string, like stub_chain('msg1.msg2.msg3')" do
         object.stub_chain("msg1.msg2.msg3").and_return(:return_value)
-        object.msg1.msg2.msg3.should equal(:return_value)
+        expect(object.msg1.msg2.msg3).to equal(:return_value)
       end
 
       it "returns expected value from two chains with shared messages at the beginning" do
         object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
         object.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
 
-        object.msg1.msg2.msg3.msg4.should equal(:first)
-        object.msg1.msg2.msg3.msg5.should equal(:second)
+        expect(object.msg1.msg2.msg3.msg4).to equal(:first)
+        expect(object.msg1.msg2.msg3.msg5).to equal(:second)
       end
 
       it "handles private instance methods (like Object#select) in the middle of a chain" do

data/spec/rspec/mocks/stub_implementation_spec.rb

@@ -7,7 +7,7 @@ module RSpec
         it "execs the block when called" do
           obj = stub()
           obj.stub(:foo) { :bar }
-          obj.foo.should eq :bar
+          expect(obj.foo).to eq :bar
         end
       end
 
@@ -15,7 +15,7 @@ module RSpec
         it "execs the block with that arg when called" do
           obj = stub()
           obj.stub(:foo) {|given| given}
-          obj.foo(:bar).should eq :bar
+          expect(obj.foo(:bar)).to eq :bar
         end
       end
 
@@ -23,7 +23,7 @@ module RSpec
         it "execs the block when called" do
           obj = stub()
           obj.stub(:foo) {|*given| given.first}
-          obj.foo(:bar).should eq :bar
+          expect(obj.foo(:bar)).to eq :bar
         end
       end
     end
@@ -35,7 +35,7 @@ module RSpec
         def obj.foo; :original; end
         obj.stub(:foo)
         obj.unstub(:foo)
-        obj.foo.should eq :original
+        expect(obj.foo).to eq :original
       end
 
       it "removes all stubs with the supplied method name" do
@@ -44,7 +44,7 @@ module RSpec
         obj.stub(:foo).with(1)
         obj.stub(:foo).with(2)
         obj.unstub(:foo)
-        obj.foo.should eq :original
+        expect(obj.foo).to eq :original
       end
 
       it "does not remove any expectations with the same method name" do
@@ -54,7 +54,7 @@ module RSpec
         obj.stub(:foo).with(1)
         obj.stub(:foo).with(2)
         obj.unstub(:foo)
-        obj.foo(3).should eq :three
+        expect(obj.foo(3)).to eq :three
       end
 
       it "restores the correct implementations when stubbed and unstubbed on a parent and child class" do
@@ -66,15 +66,15 @@ module RSpec
         parent.unstub(:new)
         child.unstub(:new)
 
-        parent.new.should be_an_instance_of parent
-        child.new.should be_an_instance_of child
+        expect(parent.new).to be_an_instance_of parent
+        expect(child.new).to be_an_instance_of child
       end
 
       it "raises a MockExpectationError if the method has not been stubbed" do
         obj = Object.new
-        lambda do
+        expect {
           obj.unstub(:foo)
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/stub_spec.rb

@@ -33,7 +33,7 @@ module RSpec
         describe "using #{method}" do
           it "returns declared value when message is received" do
             @instance.send(method, :msg).and_return(:return_value)
-            @instance.msg.should equal(:return_value)
+            expect(@instance.msg).to equal(:return_value)
             @instance.rspec_verify
           end
         end
@@ -41,12 +41,12 @@ module RSpec
 
       it "instructs an instance to respond_to the message" do
         @instance.stub(:msg)
-        @instance.should respond_to(:msg)
+        expect(@instance).to respond_to(:msg)
       end
 
       it "instructs a class object to respond_to the message" do
         @class.stub(:msg)
-        @class.should respond_to(:msg)
+        expect(@class).to respond_to(:msg)
       end
 
       it "ignores when expected message is received with no args" do
@@ -74,43 +74,43 @@ module RSpec
 
       it "handles multiple stubbed methods" do
         @instance.stub(:msg1 => 1, :msg2 => 2)
-        @instance.msg1.should eq(1)
-        @instance.msg2.should eq(2)
+        expect(@instance.msg1).to eq(1)
+        expect(@instance.msg2).to eq(2)
       end
 
       describe "#rspec_reset" do
         it "removes stubbed methods that didn't exist" do
           @instance.stub(:non_existent_method)
           @instance.rspec_reset
-          @instance.should_not respond_to(:non_existent_method)
+          expect(@instance).not_to respond_to(:non_existent_method)
         end
 
         it "restores existing instance methods" do
           # See bug reports 8302 adn 7805
           @instance.stub(:existing_instance_method) { :stub_value }
           @instance.rspec_reset
-          @instance.existing_instance_method.should eq(:original_value)
+          expect(@instance.existing_instance_method).to eq(:original_value)
         end
 
         it "restores existing private instance methods" do
           # See bug reports 8302 adn 7805
           @instance.stub(:existing_private_instance_method) { :stub_value }
           @instance.rspec_reset
-          @instance.send(:existing_private_instance_method).should eq(:original_value)
+          expect(@instance.send(:existing_private_instance_method)).to eq(:original_value)
         end
 
         it "restores existing class methods" do
           # See bug reports 8302 adn 7805
           @class.stub(:existing_class_method) { :stub_value }
           @class.rspec_reset
-          @class.existing_class_method.should eq(:original_value)
+          expect(@class.existing_class_method).to eq(:original_value)
         end
 
         it "restores existing private class methods" do
           # See bug reports 8302 adn 7805
           @class.stub(:existing_private_class_method) { :stub_value }
           @class.rspec_reset
-          @class.send(:existing_private_class_method).should eq(:original_value)
+          expect(@class.send(:existing_private_class_method)).to eq(:original_value)
         end
 
         it "does not remove existing methods that have been stubbed twice" do
@@ -119,31 +119,50 @@ module RSpec
 
           @instance.rspec_reset
 
-          @instance.existing_instance_method.should eq(:original_value)
+          expect(@instance.existing_instance_method).to eq(:original_value)
+        end
+
+        it "correctly restores the visibility of methods whose visibility has been tweaked on the singleton class" do
+          # hello is a private method when mixed in, but public on the module
+          # itself
+          mod = Module.new {
+            extend self
+            def hello; :hello; end
+
+            private :hello
+            class << self; public :hello; end;
+          }
+
+          expect(mod.hello).to eq(:hello)
+
+          mod.stub(:hello) { :stub }
+          mod.rspec_reset
+
+          expect(mod.hello).to eq(:hello)
         end
       end
 
       it "returns values in order to consecutive calls" do
         @instance.stub(:msg).and_return("1",2,:three)
-        @instance.msg.should eq("1")
-        @instance.msg.should eq(2)
-        @instance.msg.should eq(:three)
+        expect(@instance.msg).to eq("1")
+        expect(@instance.msg).to eq(2)
+        expect(@instance.msg).to eq(:three)
       end
 
       it "keeps returning last value in consecutive calls" do
         @instance.stub(:msg).and_return("1",2,:three)
-        @instance.msg.should eq("1")
-        @instance.msg.should eq(2)
-        @instance.msg.should eq(:three)
-        @instance.msg.should eq(:three)
-        @instance.msg.should eq(:three)
+        expect(@instance.msg).to eq("1")
+        expect(@instance.msg).to eq(2)
+        expect(@instance.msg).to eq(:three)
+        expect(@instance.msg).to eq(:three)
+        expect(@instance.msg).to eq(:three)
       end
 
       it "yields a specified object" do
         @instance.stub(:method_that_yields).and_yield(:yielded_obj)
         current_value = :value_before
         @instance.method_that_yields {|val| current_value = val}
-        current_value.should eq :yielded_obj
+        expect(current_value).to eq :yielded_obj
         @instance.rspec_verify
       end
 
@@ -152,7 +171,7 @@ module RSpec
                                                        and_yield(:another_value)
         current_value = []
         @instance.method_that_yields_multiple_times {|val| current_value << val}
-        current_value.should eq [:yielded_value, :another_value]
+        expect(current_value).to eq [:yielded_value, :another_value]
         @instance.rspec_verify
       end
 
@@ -160,7 +179,7 @@ module RSpec
         yielded_obj = double("my mock")
         yielded_obj.should_receive(:foo).with(:bar)
         @instance.stub(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
-        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should eq :baz
+        expect(@instance.method_that_yields_and_returns { |o| o.foo :bar }).to eq :baz
       end
 
       it "throws when told to" do
@@ -175,13 +194,13 @@ module RSpec
 
       it "overrides a pre-existing method" do
         @stub.stub(:existing_instance_method).and_return(:updated_stub_value)
-        @stub.existing_instance_method.should eq :updated_stub_value
+        expect(@stub.existing_instance_method).to eq :updated_stub_value
       end
 
       it "overrides a pre-existing stub" do
         @stub.stub(:foo) { 'bar' }
         @stub.stub(:foo) { 'baz' }
-        @stub.foo.should eq 'baz'
+        expect(@stub.foo).to eq 'baz'
       end
 
       it "allows a stub and an expectation" do
@@ -193,7 +212,7 @@ module RSpec
 
       it "calculates return value by executing block passed to #and_return" do
         @stub.stub(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
-        @stub.something("a","b","c").should eq "cba"
+        expect(@stub.something("a","b","c")).to eq "cba"
         @stub.rspec_verify
       end
     end
@@ -212,15 +231,15 @@ module RSpec
       end
 
       it "complains if called with no arg" do
-        lambda do
+        expect {
           @stub.foo
-        end.should raise_error(/received :foo with unexpected arguments/)
+        }.to raise_error(/received :foo with unexpected arguments/)
       end
 
       it "complains if called with other arg", :github_issue => [123,147] do
-        lambda do
+        expect {
           @stub.foo("other")
-        end.should raise_error(/received :foo with unexpected arguments.*Please stub a default value/m)
+        }.to raise_error(/received :foo with unexpected arguments.*Please stub a default value/m)
       end
 
       it "does not complain if also mocked w/ different args" do
@@ -233,9 +252,9 @@ module RSpec
         @stub.should_receive(:foo).with("baz")
         @stub.foo("bar")
         @stub.foo("baz")
-        lambda do
+        expect {
           @stub.foo("other")
-        end.should raise_error
+        }.to raise_error
       end
 
       it "supports options" do