rspec-mocks 2.10.1 → 2.11.0

data/spec/rspec/mocks/argument_expectation_spec.rb

@@ -2,32 +2,32 @@ require 'spec_helper'
 
 module RSpec
   module Mocks
-    describe ArgumentExpectation do
+    describe ArgumentListMatcher do
 
       it "considers an object that responds to #matches? and #failure_message_for_should to be a matcher" do
-        argument_expecatation = RSpec::Mocks::ArgumentExpectation.new
+        argument_expectation = RSpec::Mocks::ArgumentListMatcher.new
         obj = double("matcher")
         obj.stub(:respond_to?).with(:matches?).and_return(true)
         obj.stub(:respond_to?).with(:failure_message_for_should).and_return(true)
-        argument_expecatation.is_matcher?(obj).should be_true
+        argument_expectation.send(:is_matcher?, obj).should be_true
       end
 
       it "considers an object that responds to #matches? and #failure_message to be a matcher for backward compatibility" do
-        argument_expecatation = RSpec::Mocks::ArgumentExpectation.new
+        argument_expectation = RSpec::Mocks::ArgumentListMatcher.new
         obj = double("matcher")
         obj.stub(:respond_to?).with(:matches?).and_return(true)
         obj.stub(:respond_to?).with(:failure_message_for_should).and_return(false)
         obj.stub(:respond_to?).with(:failure_message).and_return(true)
-        argument_expecatation.is_matcher?(obj).should be_true
+        argument_expectation.send(:is_matcher?, obj).should be_true
       end
 
       it "does NOT consider an object that only responds to #matches? to be a matcher" do
-        argument_expecatation = RSpec::Mocks::ArgumentExpectation.new
+        argument_expectation = RSpec::Mocks::ArgumentListMatcher.new
         obj = double("matcher")
         obj.stub(:respond_to?).with(:matches?).and_return(true)
         obj.stub(:respond_to?).with(:failure_message_for_should).and_return(false)
         obj.stub(:respond_to?).with(:failure_message).and_return(false)
-        argument_expecatation.is_matcher?(obj).should be_false
+        argument_expectation.send(:is_matcher?, obj).should be_false
       end
     end
   end

data/spec/rspec/mocks/at_least_spec.rb

@@ -123,6 +123,20 @@ module RSpec
       it "passes with at_least(0) with and_return if never called" do
         @double.should_receive(:do_something).at_least(0).times.and_return true
       end
+
+      it "uses a stub value if no value set" do
+        @double.stub(:do_something => 'foo')
+        @double.should_receive(:do_something).at_least(:once)
+        @double.do_something.should eq 'foo'
+        @double.do_something.should eq 'foo'
+      end
+
+      it "prefers its own return value over a stub" do
+        @double.stub(:do_something => 'foo')
+        @double.should_receive(:do_something).at_least(:once).and_return('bar')
+        @double.do_something.should eq 'bar'
+        @double.do_something.should eq 'bar'
+      end
     end
   end
 end

data/spec/rspec/mocks/block_return_value_spec.rb

@@ -7,6 +7,14 @@ describe "a double declaration with a block handed to:" do
       obj.should_receive(:foo) { 'bar' }
       obj.foo.should eq('bar')
     end
+
+    it "works when a multi-return stub has already been set" do
+      obj = Object.new
+      return_value = Object.new
+      obj.stub(:foo).and_return(return_value, nil)
+      obj.should_receive(:foo) { return_value }
+      obj.foo.should be(return_value)
+    end
   end
 
   describe "stub" do

data/spec/rspec/mocks/mock_spec.rb

@@ -3,11 +3,17 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe Mock do
-      treats_method_missing_as_private :subject => RSpec::Mocks::Mock.new, :noop => false
-
       before(:each) { @double = double("test double") }
       after(:each)  { @double.rspec_reset }
 
+      it "has method_missing as private" do
+        RSpec::Mocks::Mock.private_instance_methods.should include_method(:method_missing)
+      end
+
+      it "does not respond_to? method_missing (because it's private)" do
+        RSpec::Mocks::Mock.new.should_not respond_to(:method_missing)
+      end
+
       it "reports line number of expectation of unreceived message" do
         expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
         begin
@@ -176,26 +182,28 @@ module RSpec
         }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
       end
 
-      it "passes proc to expectation block without an argument", :ruby => '> 1.8.6' do
-        # We eval this because Ruby 1.8.6's syntax parser barfs on { |&block| ... }
-        # and prevents the entire spec suite from running.
-        eval("@double.should_receive(:foo) {|&block| block.call.should eq(:bar)}")
-        @double.foo { :bar }
-      end
+      context "with Ruby > 1.8.6", :unless => RUBY_VERSION.to_s == '1.8.6' do
+        it "passes proc to expectation block without an argument" do
+          # We eval this because Ruby 1.8.6's syntax parser barfs on { |&block| ... }
+          # and prevents the entire spec suite from running.
+          eval("@double.should_receive(:foo) {|&block| block.call.should eq(:bar)}")
+          @double.foo { :bar }
+        end
 
-      it "passes proc to expectation block with an argument", :ruby => '> 1.8.6' do
-        eval("@double.should_receive(:foo) {|arg, &block| block.call.should eq(:bar)}")
-        @double.foo(:arg) { :bar }
-      end
+        it "passes proc to expectation block with an argument" do
+          eval("@double.should_receive(:foo) {|arg, &block| block.call.should eq(:bar)}")
+          @double.foo(:arg) { :bar }
+        end
 
-      it "passes proc to stub block without an argurment", :ruby => '>1.8.6' do
-        eval("@double.stub(:foo) {|&block| block.call.should eq(:bar)}")
-        @double.foo { :bar }
-      end
+        it "passes proc to stub block without an argurment" do
+          eval("@double.stub(:foo) {|&block| block.call.should eq(:bar)}")
+          @double.foo { :bar }
+        end
 
-      it "passes proc to stub block with an argument", :ruby => '> 1.8.6' do
-        eval("@double.stub(:foo) {|arg, &block| block.call.should eq(:bar)}")
-        @double.foo(:arg) { :bar }
+        it "passes proc to stub block with an argument" do
+          eval("@double.stub(:foo) {|arg, &block| block.call.should eq(:bar)}")
+          @double.foo(:arg) { :bar }
+        end
       end
 
       it "fails right away when method defined as never is received" do
@@ -207,7 +215,12 @@ module RSpec
       end
 
       it "raises when told to" do
-        @double.should_receive(:something).and_raise(RuntimeError)
+        @double.should_receive(:something).and_raise(StandardError)
+        expect { @double.something }.to raise_error(StandardError)
+      end
+
+      it "raises RuntimeError by default" do
+        @double.should_receive(:something).and_raise
         expect { @double.something }.to raise_error(RuntimeError)
       end
 

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,57 +54,57 @@ 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
@@ -112,37 +112,37 @@ module RSpec
         context "using => value" do
           context "starting with the same message" do
             it "returns expected value" do
-              subject.stub_chain(:msg1, :msg2, :msg3 => :first)
-              subject.stub_chain(:msg1, :msg2, :msg4 => :second)
+              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" do
-              subject.stub_chain(:msg1, :msg2, :msg3 => :first)
-              subject.stub_chain(:msg4, :msg2, :msg3 => :second)
+              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
+