rspec-mocks 2.13.1 → 2.14.0.rc1

data/spec/rspec/mocks/double_spec.rb

@@ -4,9 +4,21 @@ describe "double" do
   it "is an alias for stub and mock" do
     expect(double()).to be_a(RSpec::Mocks::Mock)
   end
-  
+
   it "uses 'Double' in failure messages" do
     double = double('name')
     expect {double.foo}.to raise_error(/Double "name" received/)
   end
+
+  describe "deprecated aliases" do
+    it "warns if #stub is used" do
+      expect(RSpec).to receive(:deprecate).with("stub", :replacement => "double")
+      stub("TestDouble")
+    end
+
+    it "warns if #mock is used" do
+      expect(RSpec).to receive(:deprecate).with("mock", :replacement => "double")
+      mock("TestDouble")
+    end
+  end
 end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -9,7 +9,7 @@ module RSpec
       end
 
       after(:each) do
-        @double.rspec_reset
+        reset @double
       end
 
       it "rejects non boolean" do
@@ -89,6 +89,22 @@ module RSpec
           @double.msg :no_msg_for_you
         end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end
+
+      it "fails with sensible message when args respond to #description" do
+        arg = Class.new do
+          def description
+          end
+
+          def inspect
+            "my_thing"
+          end
+        end.new
+
+        expect do
+          @double.should_receive(:msg).with(3)
+          @double.msg arg
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (3)\n       got: (my_thing)")
+      end
     end
   end
 end

data/spec/rspec/mocks/hash_excluding_matcher_spec.rb

@@ -4,20 +4,20 @@ module RSpec
   module Mocks
     module ArgumentMatchers
       describe HashExcludingMatcher do
-        
+
         it "describes itself properly" do
           expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
-        end      
+        end
 
         describe "passing" do
           it "matches a hash without the specified key" do
             expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
           end
-          
+
           it "matches a hash with the specified key, but different value" do
             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
             expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
           end
@@ -25,38 +25,38 @@ module RSpec
           it "matches an empty hash" do
             expect(hash_not_including(:a)).to eq({})
           end
-          
+
           it "matches a hash without any of the specified keys" do
             expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
           end
-          
+
         end
-        
+
         describe "failing" do
           it "does not match a non-hash" do
             expect(hash_not_including(:a => 1)).not_to eq 1
           end
-          
+
           it "does not match a hash with a specified key" do
             expect(hash_not_including(:b)).not_to eq(:b => 2)
           end
-          
+
           it "does not match a hash with the specified key/value pair" do
             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
             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
             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
             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
             expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
           end

data/spec/rspec/mocks/matchers/have_received_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Matchers::HaveReceived do
+      describe "expect(...).to have_received" do
+        it 'passes when the double has received the given message' do
+          dbl = double_with_met_expectation(:expected_method)
+          expect(dbl).to have_received(:expected_method)
+        end
+
+        it 'passes when a null object has received the given message' do
+          dbl = null_object_with_met_expectation(:expected_method)
+          expect(dbl).to have_received(:expected_method)
+        end
+
+        it 'fails when the double has not received the given message' do
+          dbl = double_with_unmet_expectation(:expected_method)
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/expected: 1 time/)
+        end
+
+        it 'fails when a null object has not received the given message' do
+          dbl = double.as_null_object
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/expected: 1 time/)
+        end
+
+        it 'fails when the method has not been previously stubbed' do
+          dbl = double
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/method has not been stubbed/)
+        end
+
+        it 'fails when the method has been mocked' do
+          dbl = double
+          dbl.should_receive(:expected_method)
+          dbl.expected_method
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/method has been mocked instead of stubbed/)
+        end
+
+        it 'resets expectations on class methods when mocks are reset' do
+          dbl = Object
+          dbl.stub(:expected_method)
+          dbl.expected_method
+          reset dbl
+          dbl.stub(:expected_method)
+
+          expect {
+            expect(dbl).to have_received(:expected_method)
+          }.to raise_error(/0 times/)
+        end
+
+        context "with" do
+          it 'passes when the given args match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+            expect(dbl).to have_received(:expected_method).with(:expected, :args)
+          end
+
+          it 'fails when the given args do not match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+
+            expect {
+              expect(dbl).to have_received(:expected_method).with(:unexpected, :args)
+            }.to raise_error(/with unexpected arguments/)
+          end
+        end
+
+        it 'generates a useful description' do
+          matcher = have_received(:expected_method).with(:expected_args).once
+          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
+        end
+
+        context "counts" do
+          let(:dbl) { double(:expected_method => nil) }
+
+          before do
+            dbl.expected_method
+            dbl.expected_method
+            dbl.expected_method
+          end
+
+          context "exactly" do
+            it 'passes when the message was received the given number of times' do
+              expect(dbl).to have_received(:expected_method).exactly(3).times
+            end
+
+            it 'fails when the message was received more times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).exactly(2).times
+              }.to raise_error(/expected: 2 times.*received: 3 times/m)
+            end
+
+            it 'fails when the message was received fewer times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).exactly(4).times
+              }.to raise_error(/expected: 4 times.*received: 3 times/m)
+            end
+          end
+
+          context 'at_least' do
+            it 'passes when the message was received the given number of times' do
+              expect(dbl).to have_received(:expected_method).at_least(3).times
+            end
+
+            it 'passes when the message was received more times' do
+              expect(dbl).to have_received(:expected_method).at_least(2).times
+            end
+
+            it 'fails when the message was received fewer times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).at_least(4).times
+              }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
+            end
+          end
+
+          context 'at_most' do
+            it 'passes when the message was received the given number of times' do
+              expect(dbl).to have_received(:expected_method).at_most(3).times
+            end
+
+            it 'passes when the message was received fewer times' do
+              expect(dbl).to have_received(:expected_method).at_most(4).times
+            end
+
+            it 'fails when the message was received more times' do
+              expect {
+                expect(dbl).to have_received(:expected_method).at_most(2).times
+              }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
+            end
+          end
+
+          context 'once' do
+            it 'passes when the message was received once' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              expect(dbl).to have_received(:expected_method).once
+            end
+
+            it 'fails when the message was never received' do
+              dbl = double(:expected_method => nil)
+
+              expect {
+                expect(dbl).to have_received(:expected_method).once
+              }.to raise_error(/expected: 1 time.*received: 0 times/m)
+            end
+
+            it 'fails when the message was received twice' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              dbl.expected_method
+
+              expect {
+                expect(dbl).to have_received(:expected_method).once
+              }.to raise_error(/expected: 1 time.*received: 2 times/m)
+            end
+          end
+
+          context 'twice' do
+            it 'passes when the message was received twice' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              dbl.expected_method
+
+              expect(dbl).to have_received(:expected_method).twice
+            end
+
+            it 'fails when the message was received once' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+
+              expect {
+                expect(dbl).to have_received(:expected_method).twice
+              }.to raise_error(/expected: 2 times.*received: 1 time/m)
+            end
+
+            it 'fails when the message was received thrice' do
+              dbl = double(:expected_method => nil)
+              dbl.expected_method
+              dbl.expected_method
+              dbl.expected_method
+
+              expect {
+                expect(dbl).to have_received(:expected_method).twice
+              }.to raise_error(/expected: 2 times.*received: 3 times/m)
+            end
+          end
+        end
+      end
+
+      describe "expect(...).not_to have_received" do
+        it 'passes when the double has not received the given message' do
+          dbl = double_with_unmet_expectation(:expected_method)
+          expect(dbl).not_to have_received(:expected_method)
+        end
+
+        it 'fails when the double has received the given message' do
+          dbl = double_with_met_expectation(:expected_method)
+
+          expect {
+            expect(dbl).not_to have_received(:expected_method)
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'fails when the method has not been previously stubbed' do
+          dbl = double
+
+          expect {
+            expect(dbl).not_to have_received(:expected_method)
+          }.to raise_error(/method has not been stubbed/)
+        end
+
+        context "with" do
+          it 'passes when the given args do not match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+            expect(dbl).not_to have_received(:expected_method).with(:unexpected, :args)
+          end
+
+          it 'fails when the given args match the args used with the message' do
+            dbl = double_with_met_expectation(:expected_method, :expected, :args)
+
+            expect {
+              expect(dbl).not_to have_received(:expected_method).with(:expected, :args)
+            }.to raise_error(/expected: 0 times.*received: 1 time/m) # TODO: better message
+          end
+        end
+
+        %w(exactly at_least at_most times once twice).each do |constraint|
+          it "does not allow #{constraint} to be used because it creates confusion" do
+            dbl = double_with_unmet_expectation(:expected_method)
+            expect {
+              expect(dbl).not_to have_received(:expected_method).send(constraint)
+            }.to raise_error(/can't use #{constraint} when negative/)
+          end
+        end
+      end
+
+      def double_with_met_expectation(method_name, *args)
+        double = double_with_unmet_expectation(method_name)
+        meet_expectation(double, method_name, *args)
+      end
+
+      def null_object_with_met_expectation(method_name, *args)
+        meet_expectation(double.as_null_object, method_name, *args)
+      end
+
+      def meet_expectation(double, method_name, *args)
+        double.send(method_name, *args)
+        double
+      end
+
+      def double_with_unmet_expectation(method_name)
+        double('double', method_name => true)
+      end
+    end
+  end
+end

data/spec/rspec/mocks/matchers/receive_spec.rb

@@ -0,0 +1,318 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Matchers::Receive do
+      include_context "with syntax", :expect
+
+      def verify_all
+        ::RSpec::Mocks.space.verify_all
+      end
+
+      shared_examples_for "a receive matcher" do |*options|
+        it 'allows the caller to configure how the subject responds' do
+          wrapped.to receive(:foo).and_return(5)
+          expect(receiver.foo).to eq(5)
+        end
+
+        it 'allows the caller to constrain the received arguments' do
+          wrapped.to receive(:foo).with(:a)
+          receiver.foo(:a)
+
+          expect {
+            receiver.foo(:b)
+          }.to raise_error(/received :foo with unexpected arguments/)
+        end
+
+        it 'allows a `do...end` block implementation to be provided' do
+          wrapped.to receive(:foo) do
+            4
+          end
+
+          expect(receiver.foo).to eq(4)
+        end
+
+        it 'allows a `{ ... }` block implementation to be provided' do
+          wrapped.to receive(:foo) { 5 }
+          expect(receiver.foo).to eq(5)
+        end
+
+        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
+           'since that form actually binds to `receive`' do
+          wrapped.to receive(:foo) { :curly } do
+            :do_end
+          end
+
+          expect(receiver.foo).to eq(:curly)
+        end
+
+        it 'does not support other matchers', :unless => options.include?(:allow_other_matchers) do
+          expect {
+            wrapped.to eq(3)
+          }.to raise_error(UnsupportedMatcherError)
+        end
+      end
+
+      shared_examples_for "an expect syntax allowance" do |*options|
+        include_examples "a receive matcher", *options
+
+        it 'does not expect the message to be received' do
+          wrapped.to receive(:foo)
+          expect { verify_all }.not_to raise_error
+        end
+      end
+
+      shared_examples_for "an expect syntax negative allowance" do
+        it 'is disabled since this expression is confusing' do
+          expect {
+            wrapped.not_to receive(:foo)
+          }.to raise_error(/not_to receive` is not supported/)
+
+          expect {
+            wrapped.to_not receive(:foo)
+          }.to raise_error(/to_not receive` is not supported/)
+        end
+      end
+
+      shared_examples_for "an expect syntax expectation" do |*options|
+        include_examples "a receive matcher", *options
+
+        it 'sets up a message expectation that passes if the message is received' do
+          wrapped.to receive(:foo)
+          receiver.foo
+          verify_all
+        end
+
+        it 'sets up a message expectation that fails if the message is not received' do
+          wrapped.to receive(:foo)
+
+          expect {
+            verify_all
+          }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+        it "reports the line number of expectation of unreceived message", :pending => options.include?(:does_not_report_line_num) do
+          expected_error_line = __LINE__; wrapped.to receive(:foo)
+
+          expect {
+            verify_all
+          }.to raise_error { |e|
+            expect(e.backtrace.first).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
+          }
+        end
+      end
+
+      shared_examples_for "an expect syntax negative expectation" do
+        it 'sets up a negaive message expectation that passes if the message is not received' do
+          wrapped.not_to receive(:foo)
+          verify_all
+        end
+
+        it 'sets up a negative message expectation that fails if the message is received' do
+          wrapped.not_to receive(:foo)
+
+          expect {
+            receiver.foo
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'supports `to_not` as an alias for `not_to`' do
+          wrapped.to_not receive(:foo)
+
+          expect {
+            receiver.foo
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+
+        it 'allows the caller to constrain the received arguments' do
+          wrapped.not_to receive(:foo).with(:a)
+          def receiver.method_missing(*a); end # a poor man's stub...
+
+          expect {
+            receiver.foo(:b)
+          }.not_to raise_error
+
+          expect {
+            receiver.foo(:a)
+          }.to raise_error(/expected: 0 times.*received: 1 time/m)
+        end
+      end
+
+      describe "allow(...).to receive" do
+        include_examples "an expect syntax allowance" do
+          let(:receiver) { double }
+          let(:wrapped)  { allow(receiver) }
+        end
+      end
+
+      describe "allow(...).not_to receive" do
+        include_examples "an expect syntax negative allowance" do
+          let(:wrapped) { allow(double) }
+        end
+      end
+
+      describe "allow_any_instance_of(...).to receive" do
+        include_examples "an expect syntax allowance" do
+          let(:klass)    { Class.new }
+          let(:wrapped)  { allow_any_instance_of(klass) }
+          let(:receiver) { klass.new }
+        end
+      end
+
+      describe "allow_any_instance_of(...).not_to receive" do
+        include_examples "an expect syntax negative allowance" do
+          let(:wrapped) { allow_any_instance_of(Class.new) }
+        end
+      end
+
+      describe "expect(...).to receive" do
+        include_examples "an expect syntax expectation", :allow_other_matchers do
+          let(:receiver) { double }
+          let(:wrapped)  { expect(receiver) }
+        end
+      end
+
+      describe "expect_any_instance_of(...).to receive" do
+        include_examples "an expect syntax expectation", :does_not_report_line_num do
+          let(:klass)    { Class.new }
+          let(:wrapped)  { expect_any_instance_of(klass) }
+          let(:receiver) { klass.new }
+        end
+      end
+
+      describe "expect(...).not_to receive" do
+        include_examples "an expect syntax negative expectation" do
+          let(:receiver) { double }
+          let(:wrapped)  { expect(receiver) }
+        end
+      end
+
+      describe "expect_any_instance_of(...).not_to receive" do
+        include_examples "an expect syntax negative expectation" do
+          let(:klass)    { Class.new }
+          let(:wrapped)  { expect_any_instance_of(klass) }
+          let(:receiver) { klass.new }
+        end
+      end
+
+      shared_examples "using rspec-mocks in another test framework" do
+        it 'can use the `expect` syntax' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).to receive(:foo).and_return(3)
+          end
+
+          expect(dbl.foo).to eq(3)
+        end
+
+        it 'expects the method to be called when `expect` is used' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).to receive(:foo)
+          end
+
+          expect { verify dbl }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+        it 'supports `expect(...).not_to receive`' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).not_to receive(:foo)
+          end
+
+          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+
+        it 'supports `expect(...).to_not receive`' do
+          dbl = double
+
+          framework.new.instance_eval do
+            expect(dbl).to_not receive(:foo)
+          end
+
+          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
+        end
+      end
+
+      context "when used in a test framework without rspec-expectations" do
+        let(:framework) do
+          Class.new do
+            include RSpec::Mocks::ExampleMethods
+
+            def eq(value)
+              double("MyMatcher")
+            end
+          end
+        end
+
+        include_examples "using rspec-mocks in another test framework"
+
+        it 'cannot use `expect` with another matcher' do
+          expect {
+            framework.new.instance_eval do
+              expect(3).to eq(3)
+            end
+          }.to raise_error(/only the `receive` matcher is supported/)
+        end
+
+        it 'can toggle the available syntax' do
+          expect(framework.new).to respond_to(:expect)
+          RSpec::Mocks.configuration.syntax = :should
+          expect(framework.new).not_to respond_to(:expect)
+          RSpec::Mocks.configuration.syntax = :expect
+          expect(framework.new).to respond_to(:expect)
+        end
+
+        after { RSpec::Mocks.configuration.syntax = :expect }
+      end
+
+      context "when rspec-expectations is included in the test framework first" do
+        before do
+          # the examples here assume `expect` is define in RSpec::Matchers...
+          expect(RSpec::Matchers.method_defined?(:expect)).to be_true
+        end
+
+        let(:framework) do
+          Class.new do
+            include RSpec::Matchers
+            include RSpec::Mocks::ExampleMethods
+          end
+        end
+
+        include_examples "using rspec-mocks in another test framework"
+
+        it 'can use `expect` with any matcher' do
+          framework.new.instance_eval do
+            expect(3).to eq(3)
+          end
+        end
+      end
+
+      context "when rspec-expectations is included in the test framework last" do
+        before do
+          # the examples here assume `expect` is define in RSpec::Matchers...
+          expect(RSpec::Matchers.method_defined?(:expect)).to be_true
+        end
+
+        let(:framework) do
+          Class.new do
+            include RSpec::Mocks::ExampleMethods
+            include RSpec::Matchers
+          end
+        end
+
+        include_examples "using rspec-mocks in another test framework"
+
+        it 'can use `expect` with any matcher' do
+          framework.new.instance_eval do
+            expect(3).to eq(3)
+          end
+        end
+      end
+    end
+  end
+end
+