rspec-mocks 2.10.0 → 2.11.0

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -75,10 +75,10 @@ module RSpec
       context "when method is stubbed too" do
         before { @double.stub(:do_something).and_return :stub_result }
 
-        it "uses the stub return value for subsequent calls" do
+        it "uses the last value for subsequent calls" do
           @double.do_something.should equal(11)
           @double.do_something.should equal(22)
-          @double.do_something.should equal(:stub_result)
+          @double.do_something.should equal(22)
           @double.rspec_verify
         end
 

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -15,6 +15,15 @@ module RSpec
         @double.stub(:foo)
         @double.should respond_to(:foo)
       end
+
+      it "raises an error when interpolated in a string as an integer" do
+        # Not sure why, but 1.9.2 raises a different error than 1.8.7 and 1.9.3...
+        expected_error = RUBY_VERSION == '1.9.2' ?
+                         RSpec::Mocks::MockExpectationError :
+                         TypeError
+
+        expect { "%i" % @double }.to raise_error(expected_error)
+      end
     end
 
     describe "a double acting as a null object" do
@@ -36,6 +45,11 @@ module RSpec
         @double.something
       end
 
+      it 'continues to return self from an explicit expectation' do
+        @double.should_receive(:bar)
+        @double.foo.bar.should be(@double)
+      end
+
       it "fails verification when explicit exception not met" do
         lambda do
           @double.should_receive(:something)
@@ -59,6 +73,14 @@ module RSpec
         @double.message(:expected_arg)
         @double.message(:unexpected_arg)
       end
+
+      it "can be interpolated in a string as an integer" do
+        # This form of string interpolation calls
+        # @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")
+      end
     end
     
     describe "#as_null_object" do

data/spec/rspec/mocks/stub_chain_spec.rb

@@ -3,27 +3,27 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe "A chained method stub" do
-      subject { Object.new }
+      let(:object) { Object.new }
 
       context "with one method in chain" do
         context "using and_return" do
           it "returns expected value from chaining only one method call" do
-            subject.stub_chain(:msg1).and_return(:return_value)
-            subject.msg1.should equal(:return_value)
+            object.stub_chain(:msg1).and_return(:return_value)
+            object.msg1.should equal(:return_value)
           end
         end
 
         context "using a block" do
           it "returns the correct value" do
-            subject.stub_chain(:msg1) { :return_value }
-            subject.msg1.should equal(:return_value)
+            object.stub_chain(:msg1) { :return_value }
+            object.msg1.should equal(:return_value)
           end
         end
 
         context "using a hash" do
           it "returns the value of the key/value pair" do
-            subject.stub_chain(:msg1 => :return_value)
-            subject.msg1.should equal(:return_value)
+            object.stub_chain(:msg1 => :return_value)
+            object.msg1.should equal(:return_value)
           end
         end
       end
@@ -31,22 +31,22 @@ module RSpec
       context "with two methods in chain" do
         context "using and_return" do
           it "returns expected value from chaining two method calls" do
-            subject.stub_chain(:msg1, :msg2).and_return(:return_value)
-            subject.msg1.msg2.should equal(:return_value)
+            object.stub_chain(:msg1, :msg2).and_return(:return_value)
+            object.msg1.msg2.should equal(:return_value)
           end
         end
 
         context "using a block" do
           it "returns the correct value" do
-            subject.stub_chain(:msg1, :msg2) { :return_value }
-            subject.msg1.msg2.should equal(:return_value)
+            object.stub_chain(:msg1, :msg2) { :return_value }
+            object.msg1.msg2.should equal(:return_value)
           end
         end
 
         context "using a hash" do
           it "returns the value of the key/value pair" do
-            subject.stub_chain(:msg1, :msg2 => :return_value)
-            subject.msg1.msg2.should equal(:return_value)
+            object.stub_chain(:msg1, :msg2 => :return_value)
+            object.msg1.msg2.should equal(:return_value)
           end
         end
       end
@@ -54,95 +54,95 @@ module RSpec
       context "with four methods in chain" do
         context "using and_return" do
           it "returns expected value from chaining two method calls" do
-            subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
-            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+            object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+            object.msg1.msg2.msg3.msg4.should equal(:return_value)
           end
         end
 
         context "using a block" do
           it "returns the correct value" do
-            subject.stub_chain(:msg1, :msg2, :msg3, :msg4) { :return_value }
-            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+            object.stub_chain(:msg1, :msg2, :msg3, :msg4) { :return_value }
+            object.msg1.msg2.msg3.msg4.should equal(:return_value)
           end
         end
 
         context "using a hash" do
           it "returns the value of the key/value pair" do
-            subject.stub_chain(:msg1, :msg2, :msg3, :msg4 => :return_value)
-            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+            object.stub_chain(:msg1, :msg2, :msg3, :msg4 => :return_value)
+            object.msg1.msg2.msg3.msg4.should equal(:return_value)
           end
         end
 
         context "using a hash with a string key" do
           it "returns the value of the key/value pair" do
-            subject.stub_chain("msg1.msg2.msg3.msg4" => :return_value)
-            subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+            object.stub_chain("msg1.msg2.msg3.msg4" => :return_value)
+            object.msg1.msg2.msg3.msg4.should equal(:return_value)
           end
         end
       end
 
       it "returns expected value from chaining four method calls" do
-        subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
-        subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+        object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+        object.msg1.msg2.msg3.msg4.should equal(:return_value)
       end
 
       context "with messages shared across multiple chains" do
         context "using and_return" do
           context "starting with the same message" do
             it "returns expected value" do
-              subject.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
-              subject.stub_chain(:msg1, :msg2, :msg4).and_return(:second)
+              object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
+              object.stub_chain(:msg1, :msg2, :msg4).and_return(:second)
 
-              subject.msg1.msg2.msg3.should equal(:first)
-              subject.msg1.msg2.msg4.should equal(:second)
+              object.msg1.msg2.msg3.should equal(:first)
+              object.msg1.msg2.msg4.should equal(:second)
             end
           end
 
           context "starting with the different messages" do
             it "returns expected value" do
-              subject.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
-              subject.stub_chain(:msg4, :msg2, :msg3).and_return(:second)
+              object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
+              object.stub_chain(:msg4, :msg2, :msg3).and_return(:second)
 
-              subject.msg1.msg2.msg3.should equal(:first)
-              subject.msg4.msg2.msg3.should equal(:second)
+              object.msg1.msg2.msg3.should equal(:first)
+              object.msg4.msg2.msg3.should equal(:second)
             end
           end
         end
 
         context "using => value" do
           context "starting with the same message" do
-            it "returns expected value", :focus => true do
-              subject.stub_chain(:msg1, :msg2, :msg3 => :first)
-              subject.stub_chain(:msg1, :msg2, :msg4 => :second)
+            it "returns expected value" do
+              object.stub_chain(:msg1, :msg2, :msg3 => :first)
+              object.stub_chain(:msg1, :msg2, :msg4 => :second)
 
-              subject.msg1.msg2.msg3.should equal(:first)
-              subject.msg1.msg2.msg4.should equal(:second)
+              object.msg1.msg2.msg3.should equal(:first)
+              object.msg1.msg2.msg4.should equal(:second)
             end
           end
 
           context "starting with different messages" do
-            it "returns expected value", :focus => true do
-              subject.stub_chain(:msg1, :msg2, :msg3 => :first)
-              subject.stub_chain(:msg4, :msg2, :msg3 => :second)
+            it "returns expected value" do
+              object.stub_chain(:msg1, :msg2, :msg3 => :first)
+              object.stub_chain(:msg4, :msg2, :msg3 => :second)
 
-              subject.msg1.msg2.msg3.should equal(:first)
-              subject.msg4.msg2.msg3.should equal(:second)
+              object.msg1.msg2.msg3.should equal(:first)
+              object.msg4.msg2.msg3.should equal(:second)
             end
           end
         end
       end
 
       it "returns expected value when chain is a dot separated string, like stub_chain('msg1.msg2.msg3')" do
-        subject.stub_chain("msg1.msg2.msg3").and_return(:return_value)
-        subject.msg1.msg2.msg3.should equal(:return_value)
+        object.stub_chain("msg1.msg2.msg3").and_return(:return_value)
+        object.msg1.msg2.msg3.should equal(:return_value)
       end
 
       it "returns expected value from two chains with shared messages at the beginning" do
-        subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
-        subject.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
+        object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        object.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
 
-        subject.msg1.msg2.msg3.msg4.should equal(:first)
-        subject.msg1.msg2.msg3.msg5.should equal(:second)
+        object.msg1.msg2.msg3.msg4.should equal(:first)
+        object.msg1.msg2.msg3.msg5.should equal(:second)
       end
     end
   end

data/spec/rspec/mocks/stub_const_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+
+TOP_LEVEL_VALUE_CONST = 7
+
+class TestClass
+  M = :m
+  N = :n
+
+  class Nested
+    class NestedEvenMore
+    end
+  end
+end
+
+module RSpec
+  module Mocks
+    describe "Constant Stubbing" do
+      include RSpec::Mocks::RecursiveConstMethods
+
+      def reset_rspec_mocks
+        ::RSpec::Mocks.space.reset_all
+      end
+
+      shared_examples_for "loaded constant stubbing" do |const_name|
+        let!(:original_const_value) { const }
+        after { change_const_value_to(original_const_value) }
+
+        define_method :const do
+          recursive_const_get(const_name)
+        end
+
+        define_method :parent_const do
+          recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
+        end
+
+        define_method :last_const_part do
+          const_name.split('::').last
+        end
+
+        def change_const_value_to(value)
+          parent_const.send(:remove_const, last_const_part)
+          parent_const.const_set(last_const_part, value)
+        end
+
+        it 'allows it to be stubbed' do
+          const.should_not eq(7)
+          stub_const(const_name, 7)
+          const.should eq(7)
+        end
+
+        it 'resets it to its original value when rspec clears its mocks' do
+          original_value = const
+          original_value.should_not eq(:a)
+          stub_const(const_name, :a)
+          reset_rspec_mocks
+          const.should be(original_value)
+        end
+
+        it 'returns the stubbed value' do
+          orig_value = const
+          stub_const(const_name, 7).should eq(7)
+        end
+      end
+
+      shared_examples_for "unloaded constant stubbing" do |const_name|
+        before { recursive_const_defined?(const_name).should be_false }
+
+        define_method :const do
+          recursive_const_get(const_name)
+        end
+
+        define_method :parent_const do
+          recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
+        end
+
+        define_method :last_const_part do
+          const_name.split('::').last
+        end
+
+        it 'allows it to be stubbed' do
+          stub_const(const_name, 7)
+          const.should eq(7)
+        end
+
+        it 'removes the constant when rspec clears its mocks' do
+          stub_const(const_name, 7)
+          reset_rspec_mocks
+          recursive_const_defined?(const_name).should be_false
+        end
+
+        it 'returns the stubbed value' do
+          stub_const(const_name, 7).should eq(7)
+        end
+
+        it 'ignores the :transfer_nested_constants option if passed' do
+          stub = Module.new
+          stub_const(const_name, stub, :transfer_nested_constants => true)
+          stub.constants.should eq([])
+        end
+      end
+
+      describe "#stub_const" do
+        context 'for a loaded unnested constant' do
+          it_behaves_like "loaded constant stubbing", "TestClass"
+
+          it 'can be stubbed multiple times but still restores the original value properly' do
+            orig_value = TestClass
+            stub1, stub2 = Module.new, Module.new
+            stub_const("TestClass", stub1)
+            stub_const("TestClass", stub2)
+
+            reset_rspec_mocks
+            TestClass.should be(orig_value)
+          end
+
+          it 'allows nested constants to be transferred to a stub module' do
+            tc_nested = TestClass::Nested
+            stub = Module.new
+            stub_const("TestClass", stub, :transfer_nested_constants => true)
+            stub::M.should eq(:m)
+            stub::N.should eq(:n)
+            stub::Nested.should be(tc_nested)
+          end
+
+          it 'allows nested constants to be selectively transferred to a stub module' do
+            stub = Module.new
+            stub_const("TestClass", stub, :transfer_nested_constants => [:M, :N])
+            stub::M.should eq(:m)
+            stub::N.should eq(:n)
+            defined?(stub::Nested).should be_false
+          end
+
+          it 'raises an error if asked to transfer nested constants but given an object that does not support them' do
+            original_tc = TestClass
+            stub = Object.new
+            expect {
+              stub_const("TestClass", stub, :transfer_nested_constants => true)
+            }.to raise_error(ArgumentError)
+
+            TestClass.should be(original_tc)
+
+            expect {
+              stub_const("TestClass", stub, :transfer_nested_constants => [:M])
+            }.to raise_error(ArgumentError)
+
+            TestClass.should be(original_tc)
+          end
+
+          it 'raises an error if asked to transfer nested constants on a constant that does not support nested constants' do
+            stub = Module.new
+            expect {
+              stub_const("TOP_LEVEL_VALUE_CONST", stub, :transfer_nested_constants => true)
+            }.to raise_error(ArgumentError)
+
+            TOP_LEVEL_VALUE_CONST.should eq(7)
+
+            expect {
+              stub_const("TOP_LEVEL_VALUE_CONST", stub, :transfer_nested_constants => [:M])
+            }.to raise_error(ArgumentError)
+
+            TOP_LEVEL_VALUE_CONST.should eq(7)
+          end
+
+          it 'raises an error if asked to transfer a nested constant that is not defined' do
+            original_tc = TestClass
+            defined?(TestClass::V).should be_false
+            stub = Module.new
+
+            expect {
+              stub_const("TestClass", stub, :transfer_nested_constants => [:V])
+            }.to raise_error(/cannot transfer nested constant.*V/i)
+
+            TestClass.should be(original_tc)
+          end
+        end
+
+        context 'for a loaded nested constant' do
+          it_behaves_like "loaded constant stubbing", "TestClass::Nested"
+        end
+
+        context 'for a loaded deeply nested constant' do
+          it_behaves_like "loaded constant stubbing", "TestClass::Nested::NestedEvenMore"
+        end
+
+        context 'for an unloaded unnested constant' do
+          it_behaves_like "unloaded constant stubbing", "X"
+        end
+
+        context 'for an unloaded nested constant' do
+          it_behaves_like "unloaded constant stubbing", "X::Y"
+
+          it 'removes the root constant when rspec clears its mocks' do
+            defined?(X).should be_false
+            stub_const("X::Y", 7)
+            reset_rspec_mocks
+            defined?(X).should be_false
+          end
+        end
+
+        context 'for an unloaded deeply nested constant' do
+          it_behaves_like "unloaded constant stubbing", "X::Y::Z"
+
+          it 'removes the root constant when rspec clears its mocks' do
+            defined?(X).should be_false
+            stub_const("X::Y::Z", 7)
+            reset_rspec_mocks
+            defined?(X).should be_false
+          end
+        end
+
+        context 'for an unloaded constant nested within a loaded constant' do
+          it_behaves_like "unloaded constant stubbing", "TestClass::X"
+
+          it 'removes the unloaded constant but leaves the loaded constant when rspec resets its mocks' do
+            defined?(TestClass).should be_true
+            defined?(TestClass::X).should be_false
+            stub_const("TestClass::X", 7)
+            reset_rspec_mocks
+            defined?(TestClass).should be_true
+            defined?(TestClass::X).should be_false
+          end
+
+          it 'raises a helpful error if it cannot be stubbed due to an intermediary constant that is not a module' do
+            TestClass::M.should be_a(Symbol)
+            expect { stub_const("TestClass::M::X", 5) }.to raise_error(/cannot stub/i)
+          end
+        end
+
+        context 'for an unloaded constant nested deeply within a deeply nested loaded constant' do
+          it_behaves_like "unloaded constant stubbing", "TestClass::Nested::NestedEvenMore::X::Y::Z"
+
+          it 'removes the first unloaded constant but leaves the loaded nested constant when rspec resets its mocks' do
+            defined?(TestClass::Nested::NestedEvenMore).should be_true
+            defined?(TestClass::Nested::NestedEvenMore::X).should be_false
+            stub_const("TestClass::Nested::NestedEvenMore::X::Y::Z", 7)
+            reset_rspec_mocks
+            defined?(TestClass::Nested::NestedEvenMore).should be_true
+            defined?(TestClass::Nested::NestedEvenMore::X).should be_false
+          end
+        end
+      end
+    end
+
+    describe Constant do
+      describe ".original" do
+        context 'for a previously defined unstubbed constant' do
+          let(:const) { Constant.original("TestClass::M") }
+
+          it("exposes its name")                    { const.name.should eq("TestClass::M") }
+          it("indicates it was previously defined") { const.should be_previously_defined }
+          it("indicates it has not been stubbed")   { const.should_not be_stubbed }
+          it("exposes its original value")          { const.original_value.should eq(:m) }
+        end
+
+        context 'for a previously defined stubbed constant' do
+          before { stub_const("TestClass::M", :other) }
+          let(:const) { Constant.original("TestClass::M") }
+
+          it("exposes its name")                    { const.name.should eq("TestClass::M") }
+          it("indicates it was previously defined") { const.should be_previously_defined }
+          it("indicates it has been stubbed")       { const.should be_stubbed }
+          it("exposes its original value")          { const.original_value.should eq(:m) }
+        end
+
+        context 'for a previously undefined stubbed constant' do
+          before { stub_const("TestClass::Undefined", :other) }
+          let(:const) { Constant.original("TestClass::Undefined") }
+
+          it("exposes its name")                        { const.name.should eq("TestClass::Undefined") }
+          it("indicates it was not previously defined") { const.should_not be_previously_defined }
+          it("indicates it has been stubbed")           { const.should be_stubbed }
+          it("returns nil for the original value")      { const.original_value.should be_nil }
+        end
+
+        context 'for a previously undefined unstubbed constant' do
+          let(:const) { Constant.original("TestClass::Undefined") }
+
+          it("exposes its name")                        { const.name.should eq("TestClass::Undefined") }
+          it("indicates it was not previously defined") { const.should_not be_previously_defined }
+          it("indicates it has not been stubbed")       { const.should_not be_stubbed }
+          it("returns nil for the original value")      { const.original_value.should be_nil }
+        end
+
+        context 'for a previously defined constant that has been stubbed twice' do
+          before { stub_const("TestClass::M", 1) }
+          before { stub_const("TestClass::M", 2) }
+          let(:const) { Constant.original("TestClass::M") }
+
+          it("exposes its name")                    { const.name.should eq("TestClass::M") }
+          it("indicates it was previously defined") { const.should be_previously_defined }
+          it("indicates it has been stubbed")       { const.should be_stubbed }
+          it("exposes its original value")          { const.original_value.should eq(:m) }
+        end
+
+        context 'for a previously undefined constant that has been stubbed twice' do
+          before { stub_const("TestClass::Undefined", 1) }
+          before { stub_const("TestClass::Undefined", 2) }
+          let(:const) { Constant.original("TestClass::Undefined") }
+
+          it("exposes its name")                        { const.name.should eq("TestClass::Undefined") }
+          it("indicates it was not previously defined") { const.should_not be_previously_defined }
+          it("indicates it has been stubbed")           { const.should be_stubbed }
+          it("returns nil for the original value")      { const.original_value.should be_nil }
+        end
+      end
+    end
+  end
+end
+

data/spec/rspec/mocks/stub_spec.rb

@@ -208,10 +208,10 @@ module RSpec
         end.should raise_error(/received :foo with unexpected arguments/)
       end
 
-      it "complains if called with other arg" do
+      it "complains if called with other arg", :github_issue => [123,147] do
         lambda do
           @stub.foo("other")
-        end.should raise_error(/received :foo with unexpected arguments/)
+        end.should 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

data/spec/spec_helper.rb

@@ -1,32 +1,3 @@
-require 'rspec/core'
-require 'rspec/mocks'
-require 'rspec/expectations'
-
-module Macros
-  def treats_method_missing_as_private(options = {:noop => true, :subject => nil})
-    it "has method_missing as private" do
-      self.class.describes.private_instance_methods.should include_method(:method_missing)
-    end
-
-    it "does not respond_to? method_missing (because it's private)" do
-      formatter = options[:subject] || described_class.new({ }, StringIO.new)
-      formatter.should_not respond_to(:method_missing)
-    end
-
-    if options[:noop]
-      it "should respond_to? all messages" do
-        formatter = described_class.new({ }, StringIO.new)
-        formatter.should respond_to(:just_about_anything)
-      end
-
-      it "should respond_to? anything, when given the private flag" do
-        formatter = described_class.new({ }, StringIO.new)
-        formatter.respond_to?(:method_missing, true).should be_true
-      end
-    end
-  end
-end
-
 RSpec::Matchers.define :include_method do |expected|
   match do |actual|
     actual.map { |m| m.to_s }.include?(expected.to_s)
@@ -37,17 +8,8 @@ RSpec.configure do |config|
   config.mock_with :rspec
   config.color_enabled = true
   config.order = :random
-  config.extend(Macros)
   config.include(RSpec::Mocks::Methods)
-
-  config.filter_run_excluding :ruby => lambda {|version|
-    case version.to_s
-    when "!jruby"
-      RUBY_ENGINE != "jruby"
-    when /^> (.*)/
-      !(RUBY_VERSION.to_s > $1)
-    else
-      !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
-    end
-  }
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run_including :focus
 end