rspec-mocks 2.99.4 → 3.0.0.beta1

data/spec/rspec/mocks/test_double_spec.rb

@@ -3,17 +3,15 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe TestDouble do
-      before { allow_deprecation }
-
       before(:all) do
-        Module.class_eval do
+        Module.class_exec do
           private
           def use; end
         end
       end
 
       after(:all) do
-        Module.class_eval do
+        Module.class_exec do
           undef use
         end
       end
@@ -30,12 +28,7 @@ module RSpec
 
       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(/Mock "MyDouble" received/)
-      end
-
-      it 'warns when `extend_onto` is used' do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /RSpec::Mocks::TestDouble.extend_onto/)
-        Module.new { TestDouble.extend_onto(self) }
+        expect { double.foo }.to raise_error(/Double "MyDouble" received/)
       end
 
       [[:should, :expect], [:expect], [:should]].each do |syntax|
@@ -51,18 +44,6 @@ module RSpec
           end
         end
       end
-
-      it 'indicates what type of test double it is in error messages' do
-        double = Module.new do
-          TestDouble.extend_onto(self, "A", :__declared_as => "ModuleMock")
-        end
-        expect { double.foo }.to raise_error(/ModuleMock "A"/)
-      end
-
-      it 'is declared as a mock by default' do
-        double = Module.new { TestDouble.extend_onto(self) }
-        expect { double.foo }.to raise_error(/Mock received/)
-      end
     end
   end
 end

data/spec/rspec/mocks/verifying_double_spec.rb

@@ -0,0 +1,327 @@
+require 'spec_helper'
+
+class LoadedClass
+  M = :m
+  N = :n
+  INSTANCE = LoadedClass.new
+
+  def defined_instance_method; end
+  def self.defined_class_method; end
+
+  def respond_to?(method_name)
+    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
+  end
+
+  def self.send
+    # fake out!
+  end
+
+  class Nested; 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
+        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 '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)
+          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
+
+          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 }
+          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 '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.space.reset_all
+            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
+      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
+        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
+        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(NameError)
+        end
+
+        it 'prevents creation of class doubles for unloaded constants' do
+          expect {
+            class_double('LoadedClas')
+          }.to raise_error(NameError)
+        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
+    end
+  end
+end

data/spec/rspec/mocks/verifying_message_expecation_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe VerifyingMessageExpectation do
+      describe '#with' do
+        let(:error_generator) { double.as_null_object }
+        let(:string_module_reference) { DirectModuleReference.new(String) }
+
+        subject {
+          null = double.as_null_object
+
+          described_class.new(error_generator, null, null, null)
+        }
+
+        describe 'when expected method is not loaded' do
+          it 'allows any arguments to be expected' do
+            subject.with(:foo, :bar)
+          end
+        end
+
+        describe 'when arity match fails' do
+          it 'raises error' do
+            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
+            expect(error_generator).to receive(:raise_arity_error).
+              with(instance_of(ArityCalculator), 2)
+
+            subject.with("abc123", "xyz987")
+          end
+        end
+
+        describe 'when called with arguments' do
+          it 'matches arity against the number of arguments' do
+            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
+            expect(error_generator).not_to receive(:raise_arity_error)
+
+            subject.with("abc123")
+          end
+        end
+
+        describe 'when called with any arguments matcher' do
+          it 'does not try to match arity' do
+            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
+            subject.with(any_args)
+          end
+        end
+
+        describe 'when called with no arguments matcher' do
+          it 'matches arity to 0' do
+            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
+            expect(error_generator).to receive(:raise_arity_error).
+              with(instance_of(ArityCalculator), 0)
+
+            subject.with(no_args)
+          end
+        end
+
+        describe 'when called with no arguments and no block' do
+          it 'raises' do
+            expect {
+              subject.with
+            }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rspec/mocks_spec.rb

@@ -2,25 +2,6 @@ require "spec_helper"
 
 describe RSpec::Mocks do
   describe "::setup" do
-    it "prints a deprecation warning when given a non-rspec host" do
-      o = Object.new
-      expect(RSpec).to receive(:deprecate).with(
-        "The host argument to `RSpec::Mocks.setup`",
-        :replacement=>"`include RSpec::Mocks::ExampleMethods` in #{o}"
-      )
-      RSpec::Mocks::setup(o)
-    end
-
-    it "prints the deprecation warning with the correct line" do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      RSpec::Mocks::setup(Object.new)
-    end
-
-    it "does not print a deprecation warning when self (the example group) is passed." do
-      expect(RSpec).not_to receive(:deprecate)
-      RSpec::Mocks::setup(self)
-    end
-
     context "with an existing Mock::Space" do
       before do
         @orig_space = RSpec::Mocks::space
@@ -31,12 +12,20 @@ describe RSpec::Mocks do
       end
 
       it "memoizes the space" do
-        RSpec::Mocks::setup
+        RSpec::Mocks::setup(Object.new)
         space = RSpec::Mocks::space
-        RSpec::Mocks::setup
+        RSpec::Mocks::setup(Object.new)
         expect(RSpec::Mocks::space).to equal(space)
       end
     end
+
+    context "with no pre-existing Mock::Space" do
+      it "initializes a Mock::Space" do
+        RSpec::Mocks::space = nil
+        RSpec::Mocks::setup(Object.new)
+        expect(RSpec::Mocks::space).not_to be_nil
+      end
+    end
   end
 
   describe "::verify" do
@@ -51,11 +40,12 @@ describe RSpec::Mocks do
 
   describe "::teardown" do
     it "delegates to the space" do
-      foo = "foo"
-      foo.stub(:reverse) { "reversed" }
-      RSpec::Mocks.teardown
-      RSpec::Mocks.setup
-      expect(foo.reverse).to eq("oof")
+      foo = double
+      foo.should_receive(:bar)
+      RSpec::Mocks::teardown
+      expect do
+        foo.bar
+      end.to raise_error(/received unexpected message/)
     end
   end
 
@@ -66,13 +56,6 @@ describe RSpec::Mocks do
     end
   end
 
-  context 'when requiring spec/mocks (as was valid for rspec 1)' do
-    it 'prints a deprecation warning' do
-      expect(::RSpec).to receive(:deprecate).with("require 'spec/mocks'", :replacement => "require 'rspec/mocks'")
-      load "spec/mocks.rb"
-    end
-  end
-
   def file_contents_for(lib, filename)
     # http://rubular.com/r/HYpUMftlG2
     path = $LOAD_PATH.find { |p| p.match(/\/rspec-#{lib}(-[a-f0-9]+)?\/lib/) }
@@ -80,10 +63,4 @@ describe RSpec::Mocks do
     File.read(file)
   end
 
-  it 'has an up-to-date caller_filter file' do
-    mocks = file_contents_for("mocks", "rspec/mocks/caller_filter.rb")
-    core  = file_contents_for("core",  "rspec/core/caller_filter.rb")
-
-    expect(mocks).to eq(core)
-  end
 end