rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/stubbed_message_expectations_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe "expection set on previously stubbed method" do
-  it "fails if message is not received after expectation is set" do
-    double = double(:msg => nil)
-    double.msg
-    double.should_receive(:msg)
-    expect { verify double }.to raise_error(RSpec::Mocks::MockExpectationError)
-  end
-
-  it "outputs arguments of similar calls" do
-    double = double('double', :foo => true)
-    double.should_receive(:foo).with('first')
-    double.foo('second')
-    double.foo('third')
-    expect {
-      verify double
-    }.to raise_error(%Q|Double "double" received :foo with unexpected arguments\n  expected: ("first")\n       got: ("second"), ("third")|)
-    reset double
-  end
-
-  context "with argument constraint on stub" do
-    it "matches any args if no arg constraint set on expectation" do
-      double = double("mock")
-      double.stub(:foo).with(3).and_return("stub")
-      double.should_receive(:foo).at_least(:once).and_return("expectation")
-      double.foo
-      verify double
-    end
-
-    it "matches specific args set on expectation" do
-      double = double("mock")
-      double.stub(:foo).with(3).and_return("stub")
-      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
-      double.foo(4)
-      verify double
-    end
-
-    it "fails if expectation's arg constraint is not met" do
-      double = double("mock")
-      double.stub(:foo).with(3).and_return("stub")
-      double.should_receive(:foo).at_least(:once).with(4).and_return("expectation")
-      double.foo(3)
-      expect { verify double }.to raise_error(/expected: \(4\)\s+got: \(3\)/)
-    end
-
-    it 'distinguishes between individual values and arrays properly' do
-      dbl = double
-      dbl.stub(:foo).with('a', ['b'])
-
-      expect {
-        dbl.foo(['a'], 'b')
-      }.to raise_error { |e|
-        expect(e.message).to include('expected: ("a", ["b"])', 'got: (["a"], "b")')
-      }
-    end
-  end
-end

data/spec/rspec/mocks/syntax_agnostic_message_matchers_spec.rb

@@ -1,101 +0,0 @@
-require "spec_helper"
-
-module RSpec
-  module Mocks
-
-    describe ".allow_message" do
-      let(:subject) { Object.new }
-
-      it "sets up basic message allowance" do
-        expect {
-          ::RSpec::Mocks.allow_message(subject, :basic)
-        }.to change {
-          subject.respond_to?(:basic)
-        }.to(true)
-
-        expect(subject.basic).to eq(nil)
-      end
-
-      it "sets up message allowance with params and return value" do
-        expect {
-          ::RSpec::Mocks.allow_message(subject, :x).with(:in).and_return(:out)
-        }.to change {
-          subject.respond_to?(:x)
-        }.to(true)
-
-        expect(subject.x(:in)).to eq(:out)
-      end
-
-      it "supports block implementations" do
-        ::RSpec::Mocks.allow_message(subject, :message) { :value }
-        expect(subject.message).to eq(:value)
-      end
-
-      it "does not set an expectation that the message will be received" do
-        ::RSpec::Mocks.allow_message(subject, :message)
-        expect { verify subject }.not_to raise_error
-      end
-
-      it 'does not get confused when the string and symbol message form are both used' do
-        ::RSpec::Mocks.allow_message(subject, :foo).with(1) { :a }
-        ::RSpec::Mocks.allow_message(subject, "foo").with(2) { :b }
-
-        expect(subject.foo(1)).to eq(:a)
-        expect(subject.foo(2)).to eq(:b)
-
-        reset subject
-      end
-    end
-
-    describe ".expect_message" do
-      let(:subject) { Object.new }
-
-      it "sets up basic message expectation, verifies as uncalled" do
-        expect {
-          ::RSpec::Mocks.expect_message(subject, :basic)
-        }.to change {
-          subject.respond_to?(:basic)
-        }.to(true)
-
-        expect { verify subject }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails if never is specified and the message is called" do
-        expect {
-          ::RSpec::Mocks.expect_message(subject, :foo).never
-          subject.foo
-        }.to raise_error(/expected.*0 times/)
-      end
-
-      it "sets up basic message expectation, verifies as called" do
-        ::RSpec::Mocks.expect_message(subject, :basic)
-        subject.basic
-        verify subject
-      end
-
-      it "sets up message expectation with params and return value" do
-        ::RSpec::Mocks.expect_message(subject, :msg).with(:in).and_return(:out)
-        expect(subject.msg(:in)).to eq(:out)
-        verify subject
-      end
-
-      it "accepts a block implementation for the expected message" do
-        ::RSpec::Mocks.expect_message(subject, :msg) { :value }
-        expect(subject.msg).to eq(:value)
-        verify subject
-      end
-
-      it 'does not get confused when the string and symbol message form are both used' do
-        ::RSpec::Mocks.expect_message(subject, :foo).with(1)
-        ::RSpec::Mocks.expect_message(subject, "foo").with(2)
-
-        subject.foo(1)
-        subject.foo(2)
-
-        verify subject
-      end
-
-    end
-
-  end
-end

data/spec/rspec/mocks/syntax_spec.rb

@@ -1,19 +0,0 @@
-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

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe TestDouble do
-      before(:all) do
-        Module.class_exec do
-          private
-          def use; end
-        end
-      end
-
-      after(:all) do
-        Module.class_exec do
-          undef use
-        end
-      end
-
-      it 'can be extended onto a module to make it a pure test double that can mock private methods' do
-        double = Module.new
-        double.stub(:use)
-        expect { double.use }.to raise_error(/private method `use' called/)
-
-        double = Module.new { TestDouble.extend_onto(self) }
-        double.should_receive(:use).and_return(:ok)
-        expect(double.use).to be(:ok)
-      end
-
-      it 'sets the test double name when a name is passed' do
-        double = Module.new { TestDouble.extend_onto(self, "MyDouble") }
-        expect { double.foo }.to raise_error(/Double "MyDouble" received/)
-      end
-
-      [[:should, :expect], [:expect], [:should]].each do |syntax|
-        context "with syntax #{syntax.inspect}" do
-          include_context "with syntax", syntax
-          it 'stubs the methods passed in the stubs hash' do
-            double = Module.new do
-              TestDouble.extend_onto(self, "MyDouble", :a => 5, :b => 10)
-            end
-
-            expect(double.a).to eq(5)
-            expect(double.b).to eq(10)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/to_ary_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-describe "a double receiving to_ary" do
-  shared_examples "to_ary" do
-    it "can be overridden with a stub" do
-      obj.stub(:to_ary) { :non_nil_value }
-      expect(obj.to_ary).to be(:non_nil_value)
-    end
-
-    it "responds when overriden" do
-      obj.stub(:to_ary) { :non_nil_value }
-      expect(obj).to respond_to(:to_ary)
-    end
-
-    it "supports Array#flatten" do
-      obj = double('foo')
-      expect([obj].flatten).to eq([obj])
-    end
-  end
-
-  context "double as_null_object" do
-    let(:obj) { double('obj').as_null_object }
-    include_examples "to_ary"
-
-    it "does respond to to_ary" do
-      expect(obj).to respond_to(:to_ary)
-    end
-
-    it "does respond to to_a" do
-      expect(obj).to respond_to(:to_a)
-    end
-
-    it "returns nil" do
-      expect(obj.to_ary).to eq nil
-    end
-  end
-
-  context "double without as_null_object" do
-    let(:obj) { double('obj') }
-    include_examples "to_ary"
-
-    it "doesn't respond to to_ary" do
-      expect(obj).not_to respond_to(:to_ary)
-    end
-
-    it "doesn't respond to to_a", :if => ( RUBY_VERSION.to_f > 1.8 ) do
-      expect(obj).not_to respond_to(:to_a)
-    end
-
-    it "raises " do
-      expect { obj.to_ary }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/rspec/mocks/twice_counts_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "#twice" do
-      before(:each) do
-        @double = double("test double")
-      end
-
-      it "passes when called twice" do
-        @double.should_receive(:do_something).twice
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when called twice with specified args" do
-        @double.should_receive(:do_something).twice.with("1", 1)
-        @double.do_something("1", 1)
-        @double.do_something("1", 1)
-        verify @double
-      end
-
-      it "passes when called twice with unspecified args" do
-        @double.should_receive(:do_something).twice
-        @double.do_something("1")
-        @double.do_something(1)
-        verify @double
-      end
-
-      it "fails fast when call count is higher than expected" do
-        @double.should_receive(:do_something).twice
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when call count is lower than expected" do
-        @double.should_receive(:do_something).twice
-        @double.do_something
-        expect {
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when called wrong args on the first call" do
-        @double.should_receive(:do_something).twice.with("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-
-      it "fails when called with wrong args on the second call" do
-        @double.should_receive(:do_something).twice.with("1", 1)
-        @double.do_something("1", 1)
-        expect {
-          @double.do_something(1, "1")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-    end
-  end
-end

data/spec/rspec/mocks/verifying_double_spec.rb

@@ -1,590 +0,0 @@
-require 'spec_helper'
-
-class LoadedClass
-  extend RSpec::Mocks::RubyFeatures
-
-  M = :m
-  N = :n
-  INSTANCE = LoadedClass.new
-
-  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
-
-  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
-
-  class Nested; end
-
-protected
-
-  def defined_protected_method
-  end
-
-private
-
-  def defined_private_method
-    "wink wink ;)"
-  end
-
-end
-
-module RSpec
-  module Mocks
-    describe 'verifying doubles' do
-      describe 'instance doubles' do
-        describe 'when doubled class is not loaded' do
-          include_context "with isolated configuration"
-
-          before do
-            RSpec::Mocks.configuration.verify_doubled_constant_names = false
-          end
-
-          it 'allows any instance method to be stubbed' do
-            o = instance_double('NonloadedClass')
-            o.stub(:undefined_instance_method).with(:arg).and_return(true)
-            expect(o.undefined_instance_method(:arg)).to eq(true)
-          end
-
-          it 'allows any instance method to be expected' do
-            o = instance_double("NonloadedClass")
-
-            expect(o).to receive(:undefined_instance_method).
-                           with(:arg).
-                           and_return(true)
-
-            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
-          include_context "with isolated configuration"
-
-          before do
-            RSpec::Mocks.configuration.verify_doubled_constant_names = true
-          end
-
-          it 'only allows instance methods that exist to be stubbed' do
-            o = instance_double('LoadedClass', :defined_instance_method => 1)
-            expect(o.defined_instance_method).to eq(1)
-
-            prevents { o.stub(:undefined_instance_method) }
-            prevents { o.stub(:defined_class_method) }
-          end
-
-          it 'only allows instance methods that exist to be expected' do
-            o = instance_double('LoadedClass')
-            expect(o).to receive(:defined_instance_method)
-            o.defined_instance_method
-
-            prevents { expect(o).to receive(:undefined_instance_method) }
-            prevents { expect(o).to receive(:defined_class_method) }
-            prevents { o.should_receive(:undefined_instance_method) }
-            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
-            # class itself.
-            #
-            # This spec exists as "negative" documentation of the absence of a
-            # feature, to highlight the asymmetry from class doubles (that do
-            # support this behaviour).
-            prevents {
-              instance_double('LoadedClass', :dynamic_instance_method => 1)
-            }
-          end
-
-          it 'checks the arity of stubbed methods' do
-            o = instance_double('LoadedClass')
-            prevents {
-              expect(o).to receive(:defined_instance_method).with(:a)
-            }
-          end
-
-          it 'checks that stubbed methods are invoked with the correct arity' do
-            o = instance_double('LoadedClass', :defined_instance_method => 25)
-            expect {
-              o.defined_instance_method(:a)
-            }.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
-            o = instance_double(LoadedClass, :defined_instance_method => 1)
-            expect(o.defined_instance_method).to eq(1)
-          end
-
-          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
-
-        it 'cannot be constructed with a non-module object' do
-          expect {
-            instance_double(Object.new)
-          }.to raise_error(/Module or String expected/)
-        end
-
-        it 'can be constructed with a struct' do
-          o = instance_double(Struct.new(:defined_method), :defined_method => 1)
-
-          expect(o.defined_method).to eq(1)
-        end
-      end
-
-      describe 'class doubles' do
-        describe 'when doubled class is not loaded' do
-          include_context "with isolated configuration"
-
-          before do
-            RSpec::Mocks.configuration.verify_doubled_constant_names = false
-          end
-
-          it 'allows any method to be stubbed' do
-            o = class_double('NonloadedClass')
-            allow(o).to receive(:undefined_instance_method).with(:arg).and_return(1)
-            expect(o.undefined_instance_method(:arg)).to eq(1)
-          end
-        end
-
-        describe 'when doubled class is loaded' do
-          include_context "with isolated configuration"
-
-          before do
-            RSpec::Mocks.configuration.verify_doubled_constant_names = true
-          end
-
-          it 'only allows class methods that exist to be stubbed' do
-            o = class_double('LoadedClass', :defined_class_method => 1)
-            expect(o.defined_class_method).to eq(1)
-
-            prevents { o.stub(:undefined_instance_method) }
-            prevents { o.stub(:defined_instance_method) }
-          end
-
-          it 'only allows class methods that exist to be expected' do
-            o = class_double('LoadedClass')
-            expect(o).to receive(:defined_class_method)
-            o.defined_class_method
-
-            prevents { expect(o).to receive(:undefined_instance_method) }
-            prevents { expect(o).to receive(:defined_instance_method) }
-            prevents { o.should_receive(:undefined_instance_method) }
-            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 {
-              o.defined_class_method(:a)
-            }.to raise_error(ArgumentError)
-          end
-
-          it 'allows dynamically defined class method stubs with arguments' do
-            o = class_double('LoadedClass')
-            allow(o).to receive(:dynamic_class_method).with(:a) { 1 }
-
-            expect(o.dynamic_class_method(:a)).to eq(1)
-          end
-
-          it 'allows dynamically defined class method mocks with arguments' do
-            o = class_double('LoadedClass')
-            expect(o).to receive(:dynamic_class_method).with(:a)
-
-            o.dynamic_class_method(:a)
-          end
-
-          it 'allows dynamically defined class methods to be expected' do
-            o = class_double('LoadedClass', :dynamic_class_method => 1)
-            expect(o.dynamic_class_method).to eq(1)
-          end
-
-          it 'allows class to be specified by constant' do
-            o = class_double(LoadedClass, :defined_class_method => 1)
-            expect(o.defined_class_method).to eq(1)
-          end
-
-          it 'can replace existing constants for the duration of the test' do
-            original = LoadedClass
-            object = class_double('LoadedClass').as_stubbed_const
-            expect(object).to receive(:defined_class_method)
-
-            expect(LoadedClass).to eq(object)
-            ::RSpec::Mocks.teardown
-            ::RSpec::Mocks.setup
-            expect(LoadedClass).to eq(original)
-          end
-
-          it 'can transfer nested constants to the double' do
-            class_double("LoadedClass").
-              as_stubbed_const(:transfer_nested_constants => true)
-            expect(LoadedClass::M).to eq(:m)
-            expect(LoadedClass::N).to eq(:n)
-          end
-
-          it 'correctly verifies expectations when constant is removed' do
-            dbl1 = class_double(LoadedClass::Nested).as_stubbed_const
-            class_double(LoadedClass).as_stubbed_const
-
-            prevents {
-              expect(dbl1).to receive(:undefined_class_method)
-            }
-          end
-
-          it 'only allows defined methods for null objects' do
-            o = class_double('LoadedClass').as_null_object
-
-            expect(o.defined_class_method).to eq(o)
-            prevents { o.undefined_method }
-          end
-        end
-
-        it 'cannot be constructed with a non-module object' do
-          expect {
-            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
-        it 'replaces an unloaded constant' do
-          o = object_double("LoadedClass::NOINSTANCE").as_stubbed_const
-
-          expect(LoadedClass::NOINSTANCE).to eq(o)
-
-          expect(o).to receive(:undefined_instance_method)
-          o.undefined_instance_method
-        end
-
-        it 'replaces a constant by name and verifies instances methods' do
-          o = object_double("LoadedClass::INSTANCE").as_stubbed_const
-
-          expect(LoadedClass::INSTANCE).to eq(o)
-
-          prevents { expect(o).to receive(:undefined_instance_method) }
-          prevents { expect(o).to receive(:defined_class_method) }
-          prevents { o.defined_instance_method }
-
-          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
-          o = object_double(LoadedClass.new)
-
-          prevents { expect(o).to receive(:undefined_instance_method) }
-          prevents { expect(o).to receive(:defined_class_method) }
-          prevents { o.defined_instance_method }
-
-          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
-          expect {
-            object_double("LoadedClass::INSTANCE").
-              as_stubbed_const(:transfer_nested_constants => true)
-          }.to raise_error(/Cannot transfer nested constants/)
-        end
-
-        it 'does not allow as_stubbed_constant for real objects' do
-          expect {
-            object_double(LoadedClass.new).as_stubbed_const
-          }.to raise_error(/Can not perform constant replacement with an object/)
-        end
-
-        it 'is not a module' do
-          expect(object_double("LoadedClass::INSTANCE")).to_not be_a(Module)
-        end
-      end
-
-
-      describe 'when verify_doubled_constant_names config option is set' do
-        include_context "with isolated configuration"
-
-        before do
-          RSpec::Mocks.configuration.verify_doubled_constant_names = true
-        end
-
-        it 'prevents creation of instance doubles for unloaded constants' do
-          expect {
-            instance_double('LoadedClas')
-          }.to raise_error(VerifyingDoubleNotDefinedError)
-        end
-
-        it 'prevents creation of class doubles for unloaded constants' do
-          expect {
-            class_double('LoadedClas')
-          }.to raise_error(VerifyingDoubleNotDefinedError)
-        end
-      end
-
-      it 'can only be named with a string or a module' do
-        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