rspec-mocks 2.11.3 → 2.12.0

data/spec/rspec/mocks/{stub_const_spec.rb → mutate_const_spec.rb}

@@ -18,17 +18,14 @@ end
 
 module RSpec
   module Mocks
-    describe "Constant Stubbing" do
+    describe "Constant Mutating" 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) }
-
+      shared_context "constant example methods" do |const_name|
         define_method :const do
           recursive_const_get(const_name)
         end
@@ -40,6 +37,13 @@ module RSpec
         define_method :last_const_part do
           const_name.split('::').last
         end
+      end
+
+      shared_examples_for "loaded constant stubbing" do |const_name|
+        include_context "constant example methods", const_name
+
+        let!(:original_const_value) { const }
+        after { change_const_value_to(original_const_value) }
 
         def change_const_value_to(value)
           parent_const.send(:remove_const, last_const_part)
@@ -65,20 +69,29 @@ module RSpec
         end
       end
 
-      shared_examples_for "unloaded constant stubbing" do |const_name|
-        before { recursive_const_defined?(const_name).should be_false }
+      shared_examples_for "loaded constant hiding" do |const_name|
+        before { recursive_const_defined?(const_name).should be_true }
 
-        define_method :const do
-          recursive_const_get(const_name)
+        it 'allows it to be hidden' do
+          hide_const(const_name)
+          recursive_const_defined?(const_name).should be_false
         end
 
-        define_method :parent_const do
-          recursive_const_get("Object::" + const_name.sub(/(::)?[^:]+\z/, ''))
+        it 'resets the constant when rspec clear its mocks' do
+          hide_const(const_name)
+          reset_rspec_mocks
+          recursive_const_defined?(const_name).should be_true
         end
 
-        define_method :last_const_part do
-          const_name.split('::').last
+        it 'returns nil' do
+          hide_const(const_name).should be_nil
         end
+      end
+
+      shared_examples_for "unloaded constant stubbing" do |const_name|
+        include_context "constant example methods", const_name
+
+        before { recursive_const_defined?(const_name).should be_false }
 
         it 'allows it to be stubbed' do
           stub_const(const_name, 7)
@@ -102,6 +115,85 @@ module RSpec
         end
       end
 
+      shared_examples_for "unloaded constant hiding" do |const_name|
+        include_context "constant example methods", const_name
+
+        before { recursive_const_defined?(const_name).should be_false }
+
+        it 'allows it to be hidden, though the operation has no effect' do
+          hide_const(const_name)
+          recursive_const_defined?(const_name).should be_false
+        end
+
+        it 'remains undefined after rspec clears its mocks' do
+          hide_const(const_name)
+          reset_rspec_mocks
+          recursive_const_defined?(const_name).should be_false
+        end
+
+        it 'returns nil' do
+          hide_const(const_name).should be_nil
+        end
+      end
+
+      describe "#hide_const" do
+        context 'for a loaded nested constant' do
+          it_behaves_like "loaded constant hiding", "TestClass::Nested"
+        end
+
+        context 'for an unloaded constant with nested name that matches a top-level constant' do
+          it_behaves_like "unloaded constant hiding", "TestClass::Hash"
+
+          it 'does not hide the top-level constant' do
+            top_level_hash = ::Hash
+
+            hide_const("TestClass::Hash")
+            expect(::Hash).to equal(top_level_hash)
+          end
+
+          it 'does not affect the ability to access the top-level constant from nested contexts', :silence_warnings do
+            top_level_hash = ::Hash
+
+            hide_const("TestClass::Hash")
+            expect(TestClass::Hash).to equal(top_level_hash)
+          end
+        end
+
+        context 'for a loaded deeply nested constant' do
+          it_behaves_like "loaded constant hiding", "TestClass::Nested::NestedEvenMore"
+        end
+
+        context 'for an unloaded unnested constant' do
+          it_behaves_like "unloaded constant hiding", "X"
+        end
+
+        context 'for an unloaded nested constant' do
+          it_behaves_like "unloaded constant hiding", "X::Y"
+        end
+
+        it 'can be hidden multiple times but still restores the original value properly' do
+          orig_value = TestClass
+          hide_const("TestClass")
+          hide_const("TestClass")
+
+          reset_rspec_mocks
+          TestClass.should be(orig_value)
+        end
+
+        it 'allows a constant to be hidden, then stubbed, restoring it to its original value properly' do
+          orig_value = TOP_LEVEL_VALUE_CONST
+
+          hide_const("TOP_LEVEL_VALUE_CONST")
+          recursive_const_defined?("TOP_LEVEL_VALUE_CONST").should be_false
+
+          stub_const("TOP_LEVEL_VALUE_CONST", 12345)
+          TOP_LEVEL_VALUE_CONST.should == 12345
+
+          reset_rspec_mocks
+          TOP_LEVEL_VALUE_CONST.should == orig_value
+        end
+      end
+
       describe "#stub_const" do
         context 'for a loaded unnested constant' do
           it_behaves_like "loaded constant stubbing", "TestClass"
@@ -273,7 +365,9 @@ module RSpec
 
           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 mutated")   { const.should_not be_mutated }
           it("indicates it has not been stubbed")   { const.should_not be_stubbed }
+          it("indicates it has not been hidden")    { const.should_not be_hidden }
           it("exposes its original value")          { const.original_value.should eq(:m) }
         end
 
@@ -283,7 +377,9 @@ module RSpec
 
           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 mutated")       { const.should be_mutated }
           it("indicates it has been stubbed")       { const.should be_stubbed }
+          it("indicates it has not been hidden")    { const.should_not be_hidden }
           it("exposes its original value")          { const.original_value.should eq(:m) }
         end
 
@@ -293,7 +389,9 @@ module RSpec
 
           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 mutated")           { const.should be_mutated }
           it("indicates it has been stubbed")           { const.should be_stubbed }
+          it("indicates it has not been hidden")        { const.should_not be_hidden }
           it("returns nil for the original value")      { const.original_value.should be_nil }
         end
 
@@ -302,7 +400,9 @@ module RSpec
 
           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 mutated")       { const.should_not be_mutated }
           it("indicates it has not been stubbed")       { const.should_not be_stubbed }
+          it("indicates it has not been hidden")        { const.should_not be_hidden }
           it("returns nil for the original value")      { const.original_value.should be_nil }
         end
 
@@ -313,7 +413,9 @@ module RSpec
 
           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 mutated")       { const.should be_mutated }
           it("indicates it has been stubbed")       { const.should be_stubbed }
+          it("indicates it has not been hidden")    { const.should_not be_hidden }
           it("exposes its original value")          { const.original_value.should eq(:m) }
         end
 
@@ -324,9 +426,36 @@ module RSpec
 
           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 mutated")           { const.should be_mutated }
           it("indicates it has been stubbed")           { const.should be_stubbed }
+          it("indicates it has not been hidden")        { const.should_not be_hidden }
           it("returns nil for the original value")      { const.original_value.should be_nil }
         end
+
+        context 'for a previously defined hidden constant' do
+          before { hide_const("TestClass::M") }
+          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 mutated")       { const.should be_mutated }
+          it("indicates it has not been stubbed")   { const.should_not be_stubbed }
+          it("indicates it has been hidden")        { const.should be_hidden }
+          it("exposes its original value")          { const.original_value.should eq(:m) }
+        end
+
+        context 'for a previously defined constant that has been hidden twice' do
+          before { hide_const("TestClass::M") }
+          before { hide_const("TestClass::M") }
+          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 mutated")       { const.should be_mutated }
+          it("indicates it has not been stubbed")   { const.should_not be_stubbed }
+          it("indicates it has been hidden")        { const.should be_hidden }
+          it("exposes its original value")          { const.original_value.should eq(:m) }
+        end
       end
     end
   end

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -17,8 +17,9 @@ module RSpec
       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' ?
+        # Not sure why, but 1.9.2 (but not JRuby --1.9) raises a different
+        # error than 1.8.7 and 1.9.3...
+        expected_error = (RUBY_VERSION == '1.9.2' && RUBY_PLATFORM !~ /java/) ?
                          RSpec::Mocks::MockExpectationError :
                          TypeError
 

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -3,93 +3,91 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe "using a Partial Mock," do
-      before(:each) do
-        @object = Object.new
-      end
-    
+      let(:object) { Object.new }
+
       it "names the class in the failure message" do
-        @object.should_receive(:foo)
+        object.should_receive(:foo)
         expect do
-          @object.rspec_verify
+          object.rspec_verify
         end.to raise_error(RSpec::Mocks::MockExpectationError, /\(#<Object:.*>\).foo/)
       end
-    
+
       it "names the class in the failure message when expectation is on class" do
         Object.should_receive(:foo)
         lambda do
           Object.rspec_verify
         end.should raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
       end
-    
+
       it "does not conflict with @options in the object" do
-        @object.instance_eval { @options = Object.new }
-        @object.should_receive(:blah)
-        @object.blah
+        object.instance_eval { @options = Object.new }
+        object.should_receive(:blah)
+        object.blah
       end
-            
+
       it "should_not_receive mocks out the method" do
-        @object.should_not_receive(:fuhbar)
+        object.should_not_receive(:fuhbar)
         expect {
-          @object.fuhbar
+          object.fuhbar
         }.to raise_error(
-          RSpec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError,
           /expected\: 0 times\n    received\: 1 time/
         )
       end
-    
+
       it "should_not_receive returns a negative message expectation" do
-        @object.should_not_receive(:foobar).should be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
+        object.should_not_receive(:foobar).should 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)
+        object.should_receive(:foobar).with(:test_param).and_return(1)
+        object.foobar(:test_param).should 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)
+        object.should_receive(:foobar).with(:key => "value").and_return(1)
+        object.foobar(:key => "value").should 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)
+        object.should_receive(:foobar).with(:key => "value").and_return(1)
+        object.foobar(hash[:a]).should equal(1)
       end
-    
+
       it "should_receive returns a message expectation" do
-        @object.should_receive(:foobar).should be_kind_of(RSpec::Mocks::MessageExpectation)
-        @object.foobar
+        object.should_receive(:foobar).should 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)
+        object.should_receive(:foobar).with(:test_param).and_return(1)
         lambda do
-          @object.rspec_verify
+          object.rspec_verify
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
-    
+
       it "should_receive also takes a String argument" do
-        @object.should_receive('foobar')
-        @object.foobar
+        object.should_receive('foobar')
+        object.foobar
       end
-      
+
       it "should_not_receive also takes a String argument" do
-        @object.should_not_receive('foobar')
+        object.should_not_receive('foobar')
         lambda do
-          @object.foobar   
+          object.foobar
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
-      
+
       it "uses reports nil in the error message" do
         allow_message_expectations_on_nil
-        
-        @nil = nil
-        @nil.should_receive(:foobar)
+
+        _nil = nil
+        _nil.should_receive(:foobar)
         expect {
-          @nil.rspec_verify
+          _nil.rspec_verify
         }.to raise_error(
-          RSpec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError,
           %Q|(nil).foobar(any args)\n    expected: 1 time\n    received: 0 times|
         )
       end
@@ -109,61 +107,88 @@ module RSpec
         }.to raise_error(RSpec::Mocks::MockExpectationError, /MyClass/)
       end
     end
-    
+
+    describe "Using a partial mock on a proxy object", :if => defined?(::BasicObject) do
+      let(:proxy_class) do
+        Class.new(::BasicObject) do
+          def initialize(target)
+            @target = target
+          end
+
+          def proxied?
+            true
+          end
+
+          def method_missing(*a)
+            @target.send(*a)
+          end
+        end
+      end
+
+      let(:instance) { proxy_class.new(Object.new) }
+
+      it 'works properly' do
+        instance.should_receive(:proxied?).and_return(false)
+        instance.should_not be_proxied
+      end
+    end
+
     describe "Partially mocking an object that defines ==, after another mock has been defined" do
       before(:each) do
         stub("existing mock", :foo => :foo)
       end
-      
-      class PartiallyMockedEquals
-        attr_reader :val
-        def initialize(val)
-          @val = val
-        end
-        
-        def ==(other)
-          @val == other.val
+
+      let(:klass) do
+        Class.new do
+          attr_reader :val
+          def initialize(val)
+            @val = val
+          end
+
+          def ==(other)
+            @val == other.val
+          end
         end
       end
-      
+
       it "does not raise an error when stubbing the object" do
-        o = PartiallyMockedEquals.new :foo
-        lambda { o.stub(:bar) }.should_not raise_error(NoMethodError)
+        o = klass.new :foo
+        expect { o.stub(:bar) }.not_to raise_error(NoMethodError)
       end
     end
 
     describe "Method visibility when using partial mocks" do
-      class MockableClass
-        def public_method
-          private_method
-          protected_method
+      let(:klass) do
+        Class.new do
+          def public_method
+            private_method
+            protected_method
+          end
+          protected
+          def protected_method; end
+          private
+          def private_method; end
         end
-        protected
-        def protected_method; end
-        private
-        def private_method; end
       end
 
-      before(:each) do
-        @object = MockableClass.new
-      end
+      let(:object) { klass.new }
 
       it 'keeps public methods public' do
-        @object.should_receive(:public_method)
-        @object.public_methods.should include_method(:public_method)
-        @object.public_method
+        object.should_receive(:public_method)
+        object.public_methods.should 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)
-        @object.public_method
+        object.should_receive(:private_method)
+        object.private_methods.should 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)
-        @object.public_method
+        object.should_receive(:protected_method)
+        object.protected_methods.should include_method(:protected_method)
+        object.public_method
       end
 
     end