rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -69,6 +69,16 @@ module RSpec
         verify @double
       end
 
+      it 'allows unexpected message sends using `send`' do
+        val = @double.send(:foo).send(:bar)
+        expect(val).to equal(@double)
+      end
+
+      it 'allows unexpected message sends using `send`' do
+        val = @double.__send__(:foo).__send__(:bar)
+        expect(val).to equal(@double)
+      end
+
       it "allows expected message with different args first" do
         @double.should_receive(:message).with(:expected_arg)
         @double.message(:unexpected_arg)
@@ -89,15 +99,11 @@ module RSpec
         expect(("%i" % @double)).to eq("0")
       end
 
-      it "does not allow null-ness to persist between examples" do
+      it "does not allow null objects to be used outside of examples" do
         RSpec::Mocks.teardown
 
-        expect(@double).not_to be_null_object
-        expect { @double.some.long.message.chain }.to raise_error(RSpec::Mocks::MockExpectationError)
-
-        @double.as_null_object
-        expect(@double).to be_null_object
-        expect { @double.some.long.message.chain }.not_to raise_error
+        expect { @double.some.long.message.chain }.to raise_error(RSpec::Mocks::OutsideOfExampleError)
+        expect { @double.as_null_object }.to raise_error(RSpec::Mocks::OutsideOfExampleError)
       end
     end
 

data/spec/rspec/mocks/options_hash_spec.rb

@@ -5,7 +5,7 @@ module RSpec
     describe "calling :should_receive with an options hash" do
       it "reports the file and line submitted with :expected_from" do
         begin
-          mock = RSpec::Mocks::Mock.new("a mock")
+          mock = RSpec::Mocks::Double.new("a mock")
           mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
           verify mock
         rescue Exception => e
@@ -16,7 +16,7 @@ module RSpec
 
       it "uses the message supplied with :message" do
         expect {
-          m = RSpec::Mocks::Mock.new("a mock")
+          m = RSpec::Mocks::Double.new("a mock")
           m.should_receive(:message, :message => "recebi nada")
           verify m
         }.to raise_error("recebi nada")
@@ -24,7 +24,7 @@ module RSpec
 
       it "uses the message supplied with :message after a similar stub" do
         expect {
-          m = RSpec::Mocks::Mock.new("a mock")
+          m = RSpec::Mocks::Double.new("a mock")
           m.stub(:message)
           m.should_receive(:message, :message => "from mock")
           verify m

data/spec/rspec/mocks/{partial_mock_spec.rb → partial_double_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module RSpec
   module Mocks
-    describe "using a Partial Mock," do
+    describe "A partial double" do
       let(:object) { Object.new }
 
       it "names the class in the failure message" do
@@ -298,7 +298,10 @@ module RSpec
         allow(object).to receive(:implemented)
         expect {
           object.implemented('bogus')
-        }.to raise_error(ArgumentError, /wrong number of arguments \(1 for 0\)/)
+        }.to raise_error(
+          ArgumentError,
+          a_string_including("Wrong number of arguments. Expected 0, got 1.")
+        )
       end
     end
   end

data/spec/rspec/mocks/{partial_mock_using_mocks_directly_spec.rb → partial_double_using_mocks_directly_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module RSpec::Mocks
-  describe "PartialMockUsingMocksDirectly" do
+  describe "PartialDoubleUsingMocksDirectly" do
     let(:klass) do
       Class.new do
         module MethodMissing

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -87,6 +87,14 @@ module RSpec
           @double.should_receive(:random_call).with(array_including(1,2))
           @double.random_call([1,2])
         end
+
+        it "matches any arbitrary object using #===" do
+          matcher = double
+          matcher.should_receive(:===).with(4).and_return(true)
+
+          @double.should_receive(:foo).with(matcher)
+          @double.foo(4)
+        end
       end
 
       context "handling non-matcher arguments" do
@@ -121,6 +129,16 @@ module RSpec
           @double.should_receive(:random_call).with(:a => "a", :b => "b")
           @double.random_call(opts)
         end
+
+        it "matches a class against itself" do
+          @double.should_receive(:foo).with(Fixnum)
+          @double.foo(Fixnum)
+        end
+
+        it "matches a class against an instance of itself" do
+          @double.should_receive(:foo).with(Fixnum)
+          @double.foo(3)
+        end
       end
     end
   end

data/spec/rspec/mocks/serialization_spec.rb

@@ -61,6 +61,7 @@ module RSpec
         if compiled_with_psych
           context 'using Syck as the YAML engine' do
             before(:each) { ::YAML::ENGINE.yamler = 'syck' }
+            around(:each) { |example| with_isolated_stderr(&example) }
             it_behaves_like 'normal YAML serialization'
           end
 

data/spec/rspec/mocks/space_spec.rb

@@ -2,16 +2,62 @@ require 'spec_helper'
 
 module RSpec::Mocks
   describe Space do
+    let(:space) { Space.new }
+    let(:dbl_1) { Object.new }
+    let(:dbl_2) { Object.new }
 
-    describe "#proxies_of(klass)" do
-      let(:space) { Space.new }
+    describe "#verify_all" do
+      it "verifies all mocks within" do
+        verifies = []
+
+        space.proxy_for(dbl_1).stub(:verify) { verifies << :dbl_1 }
+        space.proxy_for(dbl_2).stub(:verify) { verifies << :dbl_2 }
+
+        space.verify_all
+
+        expect(verifies).to match_array([:dbl_1, :dbl_2])
+      end
+
+      def define_singleton_method_on_recorder_for(klass, name, &block)
+        recorder = space.any_instance_recorder_for(klass)
+        (class << recorder; self; end).send(:define_method, name, &block)
+      end
+
+      it 'verifies all any_instance recorders within' do
+        klass_1, klass_2 = Class.new, Class.new
+
+        verifies = []
+
+        # We can't `stub` a method on the recorder because it defines its own `stub`...
+        define_singleton_method_on_recorder_for(klass_1, :verify) { verifies << :klass_1 }
+        define_singleton_method_on_recorder_for(klass_2, :verify) { verifies << :klass_2 }
+
+        space.verify_all
+
+        expect(verifies).to match_array([:klass_1, :klass_2])
+      end
+    end
+
+    describe "#reset_all" do
+      it "resets all mocks within" do
+        resets = []
+
+        space.proxy_for(dbl_1).stub(:reset) { resets << :dbl_1 }
+        space.proxy_for(dbl_2).stub(:reset) { resets << :dbl_2 }
+
+        space.reset_all
+
+        expect(resets).to match_array([:dbl_1, :dbl_2])
+      end
+    end
 
+    describe "#proxies_of(klass)" do
       it 'returns proxies' do
         space.proxy_for("")
-        expect(space.proxies_of(String).map(&:class)).to eq([PartialMockProxy])
+        expect(space.proxies_of(String).map(&:class)).to eq([PartialDoubleProxy])
       end
 
-      it 'returns only the proxies whose object is an instance of the given class' do
+      def create_generations
         grandparent_class = Class.new
         parent_class      = Class.new(grandparent_class)
         child_class       = Class.new(parent_class)
@@ -20,14 +66,179 @@ module RSpec::Mocks
         parent      = parent_class.new
         child       = child_class.new
 
+        return grandparent, parent, child
+      end
+
+      it 'returns only the proxies whose object is an instance of the given class' do
+        grandparent, parent, child = create_generations
+
         space.proxy_for(grandparent)
 
-        parent_proxy      = space.proxy_for(parent)
-        child_proxy       = space.proxy_for(child)
+        parent_proxy = space.proxy_for(parent)
+        child_proxy  = space.proxy_for(child)
+
+        expect(space.proxies_of(parent.class)).to contain_exactly(parent_proxy, child_proxy)
+      end
+
+      it 'looks in the parent space for matching proxies' do
+        _, parent, child = create_generations
+
+        parent_proxy = space.proxy_for(parent)
+        subspace     = space.new_scope
+        child_proxy  = subspace.proxy_for(child)
+
+        expect(subspace.proxies_of(parent.class)).to contain_exactly(parent_proxy, child_proxy)
+      end
+    end
+
+    it 'tracks proxies in parent and child space separately' do
+      proxy1   = space.proxy_for(Object.new)
+      subspace = space.new_scope
+      proxy2   = subspace.proxy_for(Object.new)
+
+      expect(space.proxies.values).to include(proxy1)
+      expect(space.proxies.values).not_to include(proxy2)
+
+      expect(subspace.proxies.values).to include(proxy2)
+      expect(subspace.proxies.values).not_to include(proxy1)
+    end
+
+    it "only adds an instance once" do
+      m1 = double("mock1")
+
+      expect {
+        space.ensure_registered(m1)
+      }.to change { space.proxies }
+
+      expect {
+        space.ensure_registered(m1)
+      }.not_to change { space.proxies }
+    end
+
+    [:ensure_registered, :proxy_for].each do |method|
+      describe "##{method}" do
+        define_method :get_proxy do |space, object|
+          space.__send__(method, object)
+        end
+
+        it 'returns the proxy for the given object' do
+          obj1 = Object.new
+          obj2 = Object.new
+
+          expect(get_proxy(space, obj1)).to equal(get_proxy(space, obj1))
+          expect(get_proxy(space, obj2)).to equal(get_proxy(space, obj2))
+          expect(get_proxy(space, obj1)).not_to equal(get_proxy(space, obj2))
+        end
+
+        it 'can stil return a proxy from a parent context' do
+          proxy    = get_proxy(space, Object)
+          subspace = space.new_scope
+
+          expect(get_proxy(subspace, Object)).to equal(proxy)
+        end
+
+        it "does not store a parent's proxy in the child space" do
+          get_proxy(space, Object)
+          subspace = space.new_scope
+
+          expect {
+            get_proxy(subspace, Object)
+          }.not_to change { subspace.proxies }.from({})
+        end
+      end
+    end
+
+    describe "#registered?" do
+      it 'returns true if registered in this space' do
+        space.ensure_registered(Object)
+        expect(space).to be_registered(Object)
+      end
+
+      it 'returns true if registered in a parent space' do
+        space.ensure_registered(Object)
+        expect(space.new_scope).to be_registered(Object)
+      end
+
+      it 'returns false if not registered in this or a parent space' do
+        expect(space.new_scope).not_to be_registered(Object)
+      end
+    end
+
+    describe "#constant_mutator_for" do
+      it 'returns the mutator for the given const name' do
+        space = RSpec::Mocks.space
+        stub_const("Foo", 3)
+        stub_const("Bar", 4)
+
+        expect(space.constant_mutator_for("Foo")).to equal(space.constant_mutator_for("Foo"))
+        expect(space.constant_mutator_for("Bar")).to equal(space.constant_mutator_for("Bar"))
+        expect(space.constant_mutator_for("Foo")).not_to equal(space.constant_mutator_for("Bar"))
+      end
 
-        expect(space.proxies_of(parent_class)).to match_array([parent_proxy, child_proxy])
+      it 'can stil return a mutator from a parent context' do
+        space = RSpec::Mocks.space
+
+        stub_const("Foo", 3)
+        mutator = space.constant_mutator_for("Foo")
+
+        in_new_space_scope do
+          subspace = RSpec::Mocks.space
+          expect(subspace.constant_mutator_for("Foo")).to equal(mutator)
+        end
+      end
+    end
+
+    describe "#any_instance_recorder_for" do
+      it 'returns the recorder for the given class' do
+        expect(space.any_instance_recorder_for(String)).to equal(space.any_instance_recorder_for(String))
+        expect(space.any_instance_recorder_for(Symbol)).to equal(space.any_instance_recorder_for(Symbol))
+        expect(space.any_instance_recorder_for(String)).not_to equal(space.any_instance_recorder_for(Symbol))
+      end
+
+      it 'can stil return a recorder from a parent context' do
+        recorder = space.any_instance_recorder_for(String)
+        subspace = space.new_scope
+
+        expect(subspace.any_instance_recorder_for(String)).to equal(recorder)
+      end
+
+      it "does not store a parent's proxy in the child space" do
+        space.any_instance_recorder_for(String)
+        subspace = space.new_scope
+
+        expect {
+          subspace.any_instance_recorder_for(String)
+        }.not_to change { subspace.any_instance_recorders }.from({})
       end
     end
 
+    it 'can be diffed in a failure when it has references to an error generator via a proxy' do
+      space1 = Space.new
+      space2 = Space.new
+
+      space1.proxy_for("")
+      space2.proxy_for("")
+
+      expect {
+        expect(space1).to eq(space2)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError, /Diff/)
+    end
+
+    it 'removes an any_instance_recorder when requested' do
+      klass = Class.new
+
+      space.any_instance_recorder_for(klass)
+
+      expect {
+        space.remove_any_instance_recorder_for(klass)
+      }.to change { space.any_instance_recorders.size }.by(-1)
+    end
+
+    def in_new_space_scope
+      RSpec::Mocks.setup
+      yield
+    ensure
+      RSpec::Mocks.teardown
+    end
   end
 end

data/spec/rspec/mocks/stub_chain_spec.rb

@@ -37,6 +37,12 @@ module RSpec
       end
 
       context "with two methods in chain" do
+        it "accepts any number of arguments to the stubbed messages in the chain" do
+          object.stub_chain(:msg1, :msg2).and_return(:return_value)
+
+          expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
+        end
+
         context "using and_return" do
           it "returns expected value from chaining two method calls" do
             object.stub_chain(:msg1, :msg2).and_return(:return_value)

data/spec/rspec/mocks/stub_spec.rb

@@ -263,12 +263,6 @@ module RSpec
         @stub.foo("bar")
         @stub.foo("baz")
       end
-
-      it "calculates return value by executing block passed to #and_return" do
-        @stub.stub(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
-        expect(@stub.something("a","b","c")).to eq "cba"
-        verify @stub
-      end
     end
 
     describe "A method stub with args" do

data/spec/rspec/mocks/syntax_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+module RSpec::Mocks
+  describe Syntax do
+    context "when the should syntax is enabled on a non-default syntax host" do
+      include_context "with the default mocks syntax"
+
+      it "continues to warn about the should syntax" do
+        my_host = Class.new
+        expect(RSpec).to receive(:deprecate)
+        Syntax.enable_should(my_host)
+
+        o = Object.new
+        o.should_receive(:bees)
+        o.bees
+      end
+    end
+  end
+end

data/spec/rspec/mocks/test_double_spec.rb

@@ -47,4 +47,3 @@ module RSpec
     end
   end
 end
-

data/spec/rspec/mocks/verifying_double_spec.rb

@@ -1,28 +1,70 @@
 require 'spec_helper'
 
 class LoadedClass
+  extend RSpec::Mocks::RubyFeatures
+
   M = :m
   N = :n
   INSTANCE = LoadedClass.new
 
-  def defined_instance_method; end
-  def self.defined_class_method; end
+  class << self
+
+    def respond_to?(method_name, include_all = false)
+      return true if method_name == :dynamic_class_method
+      super
+    end
+
+    def defined_class_method
+    end
+
+    def send
+      # fake out!
+    end
+
+  protected
+
+    def defined_protected_class_method
+    end
+
+  private
+
+    def defined_private_class_method
+    end
+
+  end
+
+  def defined_instance_method
+  end
 
-  def respond_to?(method_name)
+  if required_kw_args_supported?
+    # Need to eval this since it is invalid syntax on earlier rubies.
+    eval <<-RUBY
+      def kw_args_method(optional_arg:'hello', required_arg:)
+      end
+    RUBY
+  end
+
+  def send(*)
+  end
+
+  def respond_to?(method_name, include_all = false)
     return true if method_name == :dynamic_instance_method
     super
   end
 
-  def self.respond_to?(method_name)
-    return true if method_name == :dynamic_class_method
-    super
+  class Nested; end
+
+protected
+
+  def defined_protected_method
   end
 
-  def self.send
-    # fake out!
+private
+
+  def defined_private_method
+    "wink wink ;)"
   end
 
-  class Nested; end
 end
 
 module RSpec
@@ -51,6 +93,27 @@ module RSpec
 
             expect(o.undefined_instance_method(:arg)).to eq(true)
           end
+
+          it 'handles classes that are materialized after mocking' do
+            stub_const "A::B", Object.new
+            o = instance_double "A", :undefined_instance_method => true
+
+            expect(o.undefined_instance_method).to eq(true)
+          end
+
+          context 'for null objects' do
+            let(:o) { instance_double('NonLoadedClass').as_null_object }
+
+            it 'returns self from any message' do
+              expect(o.a.b.c).to be(o)
+            end
+
+            it 'reports it responds to any message' do
+              expect(o.respond_to?(:a)).to be true
+              expect(o.respond_to?(:a, false)).to be true
+              expect(o.respond_to?(:a, true)).to be true
+            end
+          end
         end
 
         describe 'when doubled class is loaded' do
@@ -79,6 +142,64 @@ module RSpec
             prevents { o.should_receive(:defined_class_method) }
           end
 
+          it 'allows `send` to be stubbed if it is defined on the class' do
+            o = instance_double('LoadedClass')
+            allow(o).to receive(:send).and_return("received")
+            expect(o.send(:msg)).to eq("received")
+          end
+
+          it 'gives a descriptive error message for NoMethodError' do
+            o = instance_double("LoadedClass")
+            expect {
+              o.defined_private_method
+            }.to raise_error(NoMethodError,
+                               /Double "LoadedClass \(instance\)"/)
+          end
+
+          describe "method visibility" do
+            shared_examples_for "preserves method visibility" do |visibility|
+              method_name = :"defined_#{visibility}_method"
+
+              it "can allow a #{visibility} instance method" do
+                o = instance_double('LoadedClass')
+                allow(o).to receive(method_name).and_return(3)
+                expect(o.send method_name).to eq(3)
+              end
+
+              it "can expect a #{visibility} instance method" do
+                o = instance_double('LoadedClass')
+                expect(o).to receive(method_name)
+                o.send method_name
+              end
+
+              it "preserves #{visibility} visibility when allowing a #{visibility} method" do
+                preserves_visibility(method_name, visibility) do
+                  instance_double('LoadedClass').tap do |o|
+                    allow(o).to receive(method_name)
+                  end
+                end
+              end
+
+              it "preserves #{visibility} visibility when expecting a #{visibility} method" do
+                preserves_visibility(method_name, visibility) do
+                  instance_double('LoadedClass').tap do |o|
+                    expect(o).to receive(method_name).at_least(:once)
+                    o.send(method_name) # to satisfy the expectation
+                  end
+                end
+              end
+
+              it "preserves #{visibility} visibility on a null object" do
+                preserves_visibility(method_name, visibility) do
+                  instance_double('LoadedClass').as_null_object
+                end
+              end
+            end
+
+            include_examples "preserves method visibility", :private
+            include_examples "preserves method visibility", :protected
+          end
+
           it 'does not allow dynamic methods to be expected' do
             # This isn't possible at the moment since an instance of the class
             # would be required for the verification, and we only have the
@@ -103,7 +224,23 @@ module RSpec
             o = instance_double('LoadedClass', :defined_instance_method => 25)
             expect {
               o.defined_instance_method(:a)
-            }.to raise_error(ArgumentError)
+            }.to raise_error(ArgumentError,
+                               "Wrong number of arguments. Expected 0, got 1.")
+          end
+
+          if required_kw_args_supported?
+            it 'allows keyword arguments' do
+              o = instance_double('LoadedClass', :kw_args_method => true)
+              expect(o.kw_args_method(:required_arg => 'something')).to eq(true)
+            end
+
+            it 'checks that stubbed methods with required keyword args are ' +
+               'invoked with the required arguments' do
+              o = instance_double('LoadedClass', :kw_args_method => true)
+              expect {
+                o.kw_args_method(:optional_arg => 'something')
+              }.to raise_error(ArgumentError)
+            end
           end
 
           it 'allows class to be specified by constant' do
@@ -111,11 +248,45 @@ module RSpec
             expect(o.defined_instance_method).to eq(1)
           end
 
-          it 'only allows defined methods for null objects' do
-            o = instance_double('LoadedClass').as_null_object
-
-            expect(o.defined_instance_method).to eq(o)
-            prevents { o.undefined_method }
+          context 'for null objects' do
+            let(:o) { instance_double('LoadedClass').as_null_object }
+
+            it 'only allows defined methods' do
+              expect(o.defined_instance_method).to eq(o)
+              prevents { o.undefined_method }
+              prevents { o.send(:undefined_method) }
+              prevents { o.__send__(:undefined_method) }
+            end
+
+            it 'reports what public messages it responds to accurately' do
+              expect(o.respond_to?(:defined_instance_method)).to be true
+              expect(o.respond_to?(:defined_instance_method, true)).to be true
+              expect(o.respond_to?(:defined_instance_method, false)).to be true
+
+              expect(o.respond_to?(:undefined_method)).to be false
+              expect(o.respond_to?(:undefined_method, true)).to be false
+              expect(o.respond_to?(:undefined_method, false)).to be false
+            end
+
+            it 'reports that it responds to defined private methods when the appropriate arg is passed' do
+              expect(o.respond_to?(:defined_private_method)).to be false
+              expect(o.respond_to?(:defined_private_method, true)).to be true
+              expect(o.respond_to?(:defined_private_method, false)).to be false
+            end
+
+            if RUBY_VERSION.to_f < 2.0 # respond_to?(:protected_method) changed behavior in Ruby 2.0.
+              it 'reports that it responds to protected methods' do
+                expect(o.respond_to?(:defined_protected_method)).to be true
+                expect(o.respond_to?(:defined_protected_method, true)).to be true
+                expect(o.respond_to?(:defined_protected_method, false)).to be true
+              end
+            else
+              it 'reports that it responds to protected methods when the appropriate arg is passed' do
+                expect(o.respond_to?(:defined_protected_method)).to be false
+                expect(o.respond_to?(:defined_protected_method, true)).to be true
+                expect(o.respond_to?(:defined_protected_method, false)).to be false
+              end
+            end
           end
         end
 
@@ -173,6 +344,57 @@ module RSpec
             prevents { o.should_receive(:defined_instance_method) }
           end
 
+          it 'gives a descriptive error message for NoMethodError' do
+            o = class_double("LoadedClass")
+            expect {
+              o.defined_private_class_method
+            }.to raise_error(NoMethodError, /Double "LoadedClass"/)
+          end
+
+          describe "method visibility" do
+            shared_examples_for "preserves method visibility" do |visibility|
+              method_name = :"defined_#{visibility}_class_method"
+
+              it "can allow a #{visibility} instance method" do
+                o = class_double('LoadedClass')
+                allow(o).to receive(method_name).and_return(3)
+                expect(o.send method_name).to eq(3)
+              end
+
+              it "can expect a #{visibility} instance method" do
+                o = class_double('LoadedClass')
+                expect(o).to receive(method_name)
+                o.send method_name
+              end
+
+              it "preserves #{visibility} visibility when allowing a #{visibility} method" do
+                preserves_visibility(method_name, visibility) do
+                  class_double('LoadedClass').tap do |o|
+                    allow(o).to receive(method_name)
+                  end
+                end
+              end
+
+              it "preserves #{visibility} visibility when expecting a #{visibility} method" do
+                preserves_visibility(method_name, visibility) do
+                  class_double('LoadedClass').tap do |o|
+                    expect(o).to receive(method_name).at_least(:once)
+                    o.send(method_name) # to satisfy the expectation
+                  end
+                end
+              end
+
+              it "preserves #{visibility} visibility on a null object" do
+                preserves_visibility(method_name, visibility) do
+                  class_double('LoadedClass').as_null_object
+                end
+              end
+            end
+
+            include_examples "preserves method visibility", :private
+            include_examples "preserves method visibility", :protected
+          end
+
           it 'checks that stubbed methods are invoked with the correct arity' do
             o = class_double('LoadedClass', :defined_class_method => 1)
             expect {
@@ -210,7 +432,8 @@ module RSpec
             expect(object).to receive(:defined_class_method)
 
             expect(LoadedClass).to eq(object)
-            ::RSpec::Mocks.space.reset_all
+            ::RSpec::Mocks.teardown
+            ::RSpec::Mocks.setup
             expect(LoadedClass).to eq(original)
           end
 
@@ -243,6 +466,14 @@ module RSpec
             class_double(Object.new)
           }.to raise_error(/Module or String expected/)
         end
+
+        it "trying to raise a class_double raises a TypeError", :unless => RUBY_VERSION == '1.9.2' do
+          subject = Object.new
+          class_double("StubbedError").as_stubbed_const
+          allow(subject).to receive(:some_method).and_raise(StubbedError)
+          expect { subject.some_method }.to raise_error(TypeError, 'exception class/object expected')
+        end
+
       end
 
       describe 'object doubles' do
@@ -266,6 +497,8 @@ module RSpec
 
           expect(o).to receive(:defined_instance_method)
           o.defined_instance_method
+          expect(o).to receive(:defined_private_method)
+          o.send :defined_private_method
         end
 
         it 'can create a double that matches the interface of any arbitrary object' do
@@ -277,6 +510,8 @@ module RSpec
 
           expect(o).to receive(:defined_instance_method)
           o.defined_instance_method
+          expect(o).to receive(:defined_private_method)
+          o.send :defined_private_method
         end
 
         it 'does not allow transferring constants to an object' do
@@ -308,13 +543,13 @@ module RSpec
         it 'prevents creation of instance doubles for unloaded constants' do
           expect {
             instance_double('LoadedClas')
-          }.to raise_error(NameError)
+          }.to raise_error(VerifyingDoubleNotDefinedError)
         end
 
         it 'prevents creation of class doubles for unloaded constants' do
           expect {
             class_double('LoadedClas')
-          }.to raise_error(NameError)
+          }.to raise_error(VerifyingDoubleNotDefinedError)
         end
       end
 
@@ -322,6 +557,34 @@ module RSpec
         expect { instance_double(1) }.to raise_error(ArgumentError)
         expect { instance_double(nil) }.to raise_error(ArgumentError)
       end
+
+      def preserves_visibility(method_name, visibility)
+        double = yield
+
+        expect {
+          # send bypasses visbility, so we use eval instead.
+          eval("double.#{method_name}")
+        }.to raise_error(NoMethodError, a_message_indicating_visibility_violation(method_name, visibility))
+
+        expect { double.send(method_name) }.not_to raise_error
+        expect { double.__send__(method_name) }.not_to raise_error
+
+        unless double.null_object?
+          # Null object doubles use `method_missing` and so the singleton class
+          # doesn't know what methods are defined.
+          singleton_class = class << double; self; end
+          expect(singleton_class.send("#{visibility}_method_defined?", method_name)).to be true
+        end
+      end
+
+      RSpec::Matchers.define :a_message_indicating_visibility_violation do |method_name, visibility|
+        match do |msg|
+          # This should NOT Be just `msg.match(visibility)` because the method being called
+          # has the visibility name in it. We want to ensure it's a message that ruby is
+          # stating is of the given visibility.
+          msg.match("#{visibility} ") && msg.match(method_name.to_s)
+        end
+      end
     end
   end
 end