rspec-mocks 2.12.1 → 2.12.2

data/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -11,7 +11,6 @@ end
 
 module RSpec
   module Mocks
-
     describe "an expectation set on nil" do
       it "issues a warning with file and line number information" do
         expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in .+)?. Use allow_message_expectations_on_nil to disable warnings.%
@@ -20,27 +19,24 @@ module RSpec
         nil.should_receive(:foo)
         nil.foo
       end
-      
+
       it "issues a warning when the expectation is negative" do
         Kernel.should_receive(:warn)
 
         nil.should_not_receive(:foo)
       end
-      
+
       it "does not issue a warning when expectations are set to be allowed" do
         allow_message_expectations_on_nil
         Kernel.should_not_receive(:warn)
-        
+
         nil.should_receive(:foo)
         nil.should_not_receive(:bar)
         nil.foo
       end
-
     end
-    
-    describe "#allow_message_expectations_on_nil" do
-      
 
+    describe "#allow_message_expectations_on_nil" do
       it "does not effect subsequent examples" do
         example_group = empty_example_group
         example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
@@ -51,12 +47,10 @@ module RSpec
                         nil.should_receive(:foo)
                         nil.foo
                       end
-                              
+
         example_group
-                  
       end
-
     end
-    
   end
 end
+

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -8,12 +8,12 @@ module RSpec
       end
 
       it "says it does not respond to messages it doesn't understand" do
-        @double.should_not respond_to(:foo)
+        expect(@double).not_to respond_to(:foo)
       end
 
       it "says it responds to messages it does understand" do
         @double.stub(:foo)
-        @double.should respond_to(:foo)
+        expect(@double).to respond_to(:foo)
       end
 
       it "raises an error when interpolated in a string as an integer" do
@@ -33,12 +33,12 @@ module RSpec
       end
 
       it "says it responds to everything" do
-        @double.should respond_to(:any_message_it_gets)
+        expect(@double).to respond_to(:any_message_it_gets)
       end
 
       it "allows explicit stubs" do
         @double.stub(:foo) { "bar" }
-        @double.foo.should eq("bar")
+        expect(@double.foo).to eq("bar")
       end
 
       it "allows explicit expectation" do
@@ -48,20 +48,20 @@ module RSpec
 
       it 'continues to return self from an explicit expectation' do
         @double.should_receive(:bar)
-        @double.foo.bar.should be(@double)
+        expect(@double.foo.bar).to be(@double)
       end
 
       it 'returns an explicitly stubbed value from an expectation with no implementation' do
         @double.stub(:foo => "bar")
         @double.should_receive(:foo)
-        @double.foo.should eq("bar")
+        expect(@double.foo).to eq("bar")
       end
 
       it "fails verification when explicit exception not met" do
-        lambda do
+        expect {
           @double.should_receive(:something)
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "ignores unexpected methods" do
@@ -86,21 +86,21 @@ module RSpec
         # @double.to_int.to_int.to_int...etc until it gets an integer,
         # and thus gets stuck in an infinite loop unless our double
         # returns an int value from #to_int.
-        ("%i" % @double).should eq("0")
+        expect(("%i" % @double)).to eq("0")
       end
     end
-    
+
     describe "#as_null_object" do
       it "sets the object to null_object" do
         obj = double('anything').as_null_object
-        obj.should be_null_object
+        expect(obj).to be_null_object
       end
     end
 
     describe "#null_object?" do
       it "defaults to false" do
         obj = double('anything')
-        obj.should_not be_null_object
+        expect(obj).not_to be_null_object
       end
     end
   end

data/spec/rspec/mocks/once_counts_spec.rb

@@ -27,25 +27,25 @@ module RSpec
 
       it "fails when called with wrong args" do
         @double.should_receive(:do_something).once.with("a", "b", "c")
-        lambda do
+        expect {
           @double.do_something("d", "e", "f")
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
         @double.rspec_reset
       end
 
       it "fails fast when called twice" do
         @double.should_receive(:do_something).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 when not called" do
         @double.should_receive(:do_something).once
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/options_hash_spec.rb

@@ -10,25 +10,25 @@ module RSpec
           mock.rspec_verify
         rescue Exception => e
         ensure
-          e.backtrace.to_s.should =~ /\/path\/to\/blah.ext:37/m
+          expect(e.backtrace.to_s).to match /\/path\/to\/blah.ext:37/m
         end
       end
 
       it "uses the message supplied with :message" do
-        lambda {
+        expect {
           m = RSpec::Mocks::Mock.new("a mock")
           m.should_receive(:message, :message => "recebi nada")
           m.rspec_verify
-        }.should raise_error("recebi nada")
+        }.to raise_error("recebi nada")
       end
-      
+
       it "uses the message supplied with :message after a similar stub" do
-        lambda {
+        expect {
           m = RSpec::Mocks::Mock.new("a mock")
           m.stub(:message)
           m.should_receive(:message, :message => "from mock")
           m.rspec_verify
-        }.should raise_error("from mock")
+        }.to raise_error("from mock")
       end
     end
   end

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -14,9 +14,9 @@ module RSpec
 
       it "names the class in the failure message when expectation is on class" do
         Object.should_receive(:foo)
-        lambda do
+        expect {
           Object.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
+        }.to raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
       end
 
       it "does not conflict with @options in the object" do
@@ -36,35 +36,35 @@ module RSpec
       end
 
       it "should_not_receive returns a negative message expectation" do
-        object.should_not_receive(:foobar).should be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
+        expect(object.should_not_receive(:foobar)).to be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
       end
 
       it "should_receive mocks out the method" do
         object.should_receive(:foobar).with(:test_param).and_return(1)
-        object.foobar(:test_param).should equal(1)
+        expect(object.foobar(:test_param)).to equal(1)
       end
 
       it "should_receive handles a hash" do
         object.should_receive(:foobar).with(:key => "value").and_return(1)
-        object.foobar(:key => "value").should equal(1)
+        expect(object.foobar(:key => "value")).to equal(1)
       end
 
       it "should_receive handles an inner hash" do
         hash = {:a => {:key => "value"}}
         object.should_receive(:foobar).with(:key => "value").and_return(1)
-        object.foobar(hash[:a]).should equal(1)
+        expect(object.foobar(hash[:a])).to equal(1)
       end
 
       it "should_receive returns a message expectation" do
-        object.should_receive(:foobar).should be_kind_of(RSpec::Mocks::MessageExpectation)
+        expect(object.should_receive(:foobar)).to be_kind_of(RSpec::Mocks::MessageExpectation)
         object.foobar
       end
 
       it "should_receive verifies method was called" do
         object.should_receive(:foobar).with(:test_param).and_return(1)
-        lambda do
+        expect {
           object.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "should_receive also takes a String argument" do
@@ -74,9 +74,9 @@ module RSpec
 
       it "should_not_receive also takes a String argument" do
         object.should_not_receive('foobar')
-        lambda do
+        expect {
           object.foobar
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "uses reports nil in the error message" do
@@ -129,7 +129,7 @@ module RSpec
 
       it 'works properly' do
         instance.should_receive(:proxied?).and_return(false)
-        instance.should_not be_proxied
+        expect(instance).not_to be_proxied
       end
     end
 
@@ -175,19 +175,19 @@ module RSpec
 
       it 'keeps public methods public' do
         object.should_receive(:public_method)
-        object.public_methods.should include_method(:public_method)
+        expect(object.public_methods).to include_method(:public_method)
         object.public_method
       end
 
       it 'keeps private methods private' do
         object.should_receive(:private_method)
-        object.private_methods.should include_method(:private_method)
+        expect(object.private_methods).to include_method(:private_method)
         object.public_method
       end
 
       it 'keeps protected methods protected' do
         object.should_receive(:protected_method)
-        object.protected_methods.should include_method(:protected_method)
+        expect(object.protected_methods).to include_method(:protected_method)
         object.public_method
       end
 

data/spec/rspec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -32,23 +32,23 @@ module RSpec::Mocks
     #     obj.should_receive(:msg)
     #     obj.msg
     #     obj.rspec_verify
-    #     lambda do
+    #     expect {
     #       obj.msg
-    #     end.should raise_error(NoMethodError)
-    #   
+    #     }.to raise_error(NoMethodError)
+    #
     # end
     it "fails when expected message is not received" do
       obj.should_receive(:msg)
-      lambda do
+      expect {
         obj.rspec_verify
-      end.should raise_error(RSpec::Mocks::MockExpectationError)
+      }.to raise_error(RSpec::Mocks::MockExpectationError)
     end
 
     it "fails when message is received with incorrect args" do
       obj.should_receive(:msg).with(:correct_arg)
-      lambda do
+      expect {
         obj.msg(:incorrect_arg)
-      end.should raise_error(RSpec::Mocks::MockExpectationError)
+      }.to raise_error(RSpec::Mocks::MockExpectationError)
       obj.msg(:correct_arg)
     end
 
@@ -65,30 +65,30 @@ module RSpec::Mocks
     end
 
     it "restores the original method if it existed" do
-      obj.existing_method.should equal(:original_value)
+      expect(obj.existing_method).to equal(:original_value)
       obj.should_receive(:existing_method).and_return(:mock_value)
-      obj.existing_method.should equal(:mock_value)
+      expect(obj.existing_method).to equal(:mock_value)
       obj.rspec_verify
-      obj.existing_method.should equal(:original_value)
+      expect(obj.existing_method).to equal(:original_value)
     end
 
     context "with an instance method handled by method_missing" do
       it "restores the original behavior" do
-        obj.captured_by_method_missing.should eq("response generated by method missing")
+        expect(obj.captured_by_method_missing).to eq("response generated by method missing")
         obj.stub(:captured_by_method_missing) { "foo" }
-        obj.captured_by_method_missing.should eq("foo")
+        expect(obj.captured_by_method_missing).to eq("foo")
         obj.rspec_reset
-        obj.captured_by_method_missing.should eq("response generated by method missing")
+        expect(obj.captured_by_method_missing).to eq("response generated by method missing")
       end
     end
 
-    context "with a class method handled by method_missing" do 
+    context "with a class method handled by method_missing" do
       it "restores the original behavior" do
-        klass.captured_by_method_missing.should eq("response generated by method missing")
+        expect(klass.captured_by_method_missing).to eq("response generated by method missing")
         klass.stub(:captured_by_method_missing) { "foo" }
-        klass.captured_by_method_missing.should eq("foo")
+        expect(klass.captured_by_method_missing).to eq("foo")
         klass.rspec_reset
-        klass.captured_by_method_missing.should eq("response generated by method missing")
+        expect(klass.captured_by_method_missing).to eq("response generated by method missing")
       end
     end
   end

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -87,11 +87,11 @@ module RSpec
       context "handling block matchers" do
         it "matches arguments against RSpec expectations" do
           @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
-            arg1.should eq 5
-            arg2.should have_at_least(3).characters
-            arg2.should have_at_most(10).characters
-            arr.map {|i| i * 2}.should eq [2,4,6]
-            rest.should eq [:fee, "fi", 4]
+            expect(arg1).to eq 5
+            expect(arg2).to have_at_least(3).characters
+            expect(arg2).to have_at_most(10).characters
+            expect(arr.map {|i| i * 2}).to eq [2,4,6]
+            expect(rest).to eq [:fee, "fi", 4]
           }
           @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
         end
@@ -100,7 +100,7 @@ module RSpec
           eval_count = 0
           @double.should_receive(:msg).with {|a| eval_count += 1}
           @double.msg(:ignore)
-          eval_count.should eq(1)
+          expect(eval_count).to eq(1)
         end
       end
 

data/spec/rspec/mocks/precise_counts_spec.rb

@@ -11,9 +11,9 @@ module RSpec
         @double.should_receive(:do_something).exactly(3).times
         @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 fast when exactly n times method is called more than n times" do
@@ -21,16 +21,16 @@ module RSpec
         @double.do_something
         @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 when exactly n times method is never called" do
         @double.should_receive(:do_something).exactly(3).times
-        lambda do
+        expect {
           @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "passes if exactly n times method is called exactly n times" do
@@ -43,7 +43,7 @@ module RSpec
 
       it "returns the value given by a block when the exactly once method is called" do
         @double.should_receive(:to_s).exactly(:once) { "testing" }
-        @double.to_s.should eq "testing"
+        expect(@double.to_s).to eq "testing"
         @double.rspec_verify
       end
 

data/spec/rspec/mocks/record_messages_spec.rb

@@ -7,19 +7,19 @@ module RSpec
         @mock = double("mock").as_null_object
       end
       it "answers false for received_message? when no messages received" do
-        @mock.received_message?(:message).should be_false
+        expect(@mock.received_message?(:message)).to be_false
       end
       it "answers true for received_message? when message received" do
         @mock.message
-        @mock.received_message?(:message).should be_true
+        expect(@mock.received_message?(:message)).to be_true
       end
       it "answers true for received_message? when message received with correct args" do
         @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2,3).should be_true
+        expect(@mock.received_message?(:message, 1,2,3)).to be_true
       end
       it "answers false for received_message? when message received with incorrect args" do
         @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2).should be_false
+        expect(@mock.received_message?(:message, 1,2)).to be_false
       end
     end
   end