rspec-mocks 2.99.4 → 3.0.0.beta1

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -104,7 +104,7 @@ module RSpec
 
     describe "a message expectation with multiple return values with a specified count larger than the number of values" do
       before(:each) do
-        @double = RSpec::Mocks::Double.new("double")
+        @double = RSpec::Mocks::Mock.new("double")
         @double.should_receive(:do_something).exactly(3).times.and_return(11, 22)
       end
 

data/spec/rspec/mocks/mutate_const_spec.rb

@@ -32,11 +32,6 @@ module RSpec
         ::RSpec::Mocks.space.reset_all
       end
 
-      specify "the use of ConstantStubber is deprecated" do
-        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-        expect(RSpec::Mocks::ConstantStubber).to eq RSpec::Mocks::ConstantMutator
-      end
-
       shared_context "constant example methods" do |const_name|
         define_method :const do
           recursive_const_get(const_name)
@@ -316,6 +311,24 @@ module RSpec
 
             expect(TestClass).to be(original_tc)
           end
+
+          describe 'with global transfer_nested_constant option set' do
+            include_context "with isolated configuration"
+
+            before do
+              RSpec::Mocks.configuration.transfer_nested_constants = true
+            end
+
+            it 'allows nested constants to be transferred to a stub module' do
+              tc_nested = TestClass::Nested
+              stub = Module.new
+              stub_const("TestClass", stub)
+              expect(stub::M).to eq(:m)
+              expect(stub::N).to eq(:n)
+              expect(stub::Nested).to be(tc_nested)
+            end
+          end
+
         end
 
         context 'for a loaded nested constant' do

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -89,11 +89,13 @@ module RSpec
         expect(("%i" % @double)).to eq("0")
       end
 
-      it "preserves its nullness to subsequent examples to " +
-         "maintain compatibility with <= 2.13" do
+      it "does not allow null-ness to persist between examples" do
         RSpec::Mocks.teardown
-        RSpec::Mocks.setup
-        allow(RSpec).to receive(:deprecate)
+
+        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
       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::Double.new("a mock")
+          mock = RSpec::Mocks::Mock.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::Double.new("a mock")
+          m = RSpec::Mocks::Mock.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::Double.new("a mock")
+          m = RSpec::Mocks::Mock.new("a mock")
           m.stub(:message)
           m.should_receive(:message, :message => "from mock")
           verify m

data/spec/rspec/mocks/order_group_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+describe 'OrderGroup' do
+  let(:order_group) { ::RSpec::Mocks::OrderGroup.new }
+
+  describe '#consume' do
+    let(:ordered_1) { double :ordered? => true }
+    let(:ordered_2) { double :ordered? => true }
+    let(:unordered) { double :ordered? => false }
+
+    before do
+      order_group.register unordered
+      order_group.register ordered_1
+      order_group.register unordered
+      order_group.register ordered_2
+      order_group.register unordered
+      order_group.register unordered
+    end
+
+    it 'returns the first ordered? expectation' do
+      expect(order_group.consume).to eq ordered_1
+    end
+    it 'keeps returning ordered? expectation until all are returned' do
+      expectations = 3.times.map { order_group.consume }
+      expect(expectations).to eq [ordered_1, ordered_2, nil]
+    end
+  end
+end

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -20,7 +20,7 @@ module RSpec
       end
 
       it "does not conflict with @options in the object" do
-        object.instance_eval { @options = Object.new }
+        object.instance_exec { @options = Object.new }
         object.should_receive(:blah)
         object.blah
       end
@@ -166,6 +166,35 @@ module RSpec
       end
     end
 
+    describe "A partial class mock that has been subclassed" do
+
+      let(:klass)  { Class.new }
+      let(:subklass) { Class.new(klass) }
+
+      it "cleans up stubs during #reset to prevent leakage onto subclasses between examples" do
+        allow(klass).to receive(:new).and_return(:new_foo)
+        expect(subklass.new).to eq :new_foo
+
+        reset(klass)
+
+        expect(subklass.new).to be_a(subklass)
+      end
+
+      describe "stubbing a base class class method" do
+        before do
+          klass.stub(:find).and_return "stubbed_value"
+        end
+
+        it "returns the value for the stub on the base class" do
+          expect(klass.find).to eq "stubbed_value"
+        end
+
+        it "returns the value for the descendent class" do
+          expect(subklass.find).to eq "stubbed_value"
+        end
+      end
+    end
+
     describe "Method visibility when using partial mocks" do
       let(:klass) do
         Class.new do
@@ -201,5 +230,76 @@ module RSpec
       end
 
     end
+
+    describe 'when verify_partial_doubles configuration option is set' do
+      include_context "with isolated configuration"
+
+      let(:klass) do
+        Class.new do
+          def implemented
+            "works"
+          end
+
+          def respond_to?(method_name, include_all=false)
+            method_name.to_s == "dynamic_method" || super
+          end
+
+          def method_missing(method_name, *args)
+            if respond_to?(method_name)
+              method_name
+            else
+              super
+            end
+          end
+        end
+      end
+
+      let(:object) { klass.new }
+
+      before do
+        RSpec::Mocks.configuration.verify_partial_doubles = true
+      end
+
+      it 'allows valid methods to be expected' do
+        expect(object).to receive(:implemented).and_call_original
+        expect(object.implemented).to eq("works")
+      end
+
+      it 'does not allow a non-existing method to be expected' do
+        prevents { expect(object).to receive(:unimplemented) }
+      end
+
+      it 'verifies arity range when matching arguments' do
+        prevents { expect(object).to receive(:implemented).with('bogus') }
+      end
+
+      it 'allows a method defined with method_missing to be expected' do
+        expect(object).to receive(:dynamic_method).with('a').and_call_original
+        expect(object.dynamic_method('a')).to eq(:dynamic_method)
+      end
+
+      it 'allows valid methods to be expected on any_instance' do
+        expect_any_instance_of(klass).to receive(:implemented)
+        object.implemented
+      end
+
+      it 'does not allow a non-existing method to be called on any_instance' do
+        prevents { expect_any_instance_of(klass).to receive(:unimplemented) }
+      end
+
+      it 'does not allow missing methods to be called on any_instance' do
+        # This is potentially surprising behaviour, but there is no way for us
+        # to know that this method is valid since we only have class and not an
+        # instance.
+        prevents { expect_any_instance_of(klass).to receive(:dynamic_method) }
+      end
+
+      it 'verifies arity range when receiving a message' do
+        allow(object).to receive(:implemented)
+        expect {
+          object.implemented('bogus')
+        }.to raise_error(ArgumentError, /wrong number of arguments \(1 for 0\)/)
+      end
+    end
   end
 end

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -82,27 +82,10 @@ module RSpec
           @double.should_receive(:random_call).with(hash_including(:a => 1))
           @double.random_call(:a => 1)
         end
-      end
 
-      context "handling block matchers" do
-        before { allow_deprecation }
-
-        it "matches arguments against RSpec expectations" do
-          @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
-            expect(arg1).to eq 5
-            expect(arg2.length).to be >= 3
-            expect(arg2.length).to be <= 10
-            expect(arr.map {|i| i * 2}).to eq [2,4,6]
-            expect(rest).to eq [:fee, "fi", 4]
-          }
-          @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
-        end
-
-        it "does not eval the block as the return value" do
-          eval_count = 0
-          @double.should_receive(:msg).with {|a| eval_count += 1}
-          @double.msg(:ignore)
-          expect(eval_count).to eq(1)
+        it "matches array with array_including same array" do
+          @double.should_receive(:random_call).with(array_including(1,2))
+          @double.random_call([1,2])
         end
       end
 

data/spec/rspec/mocks/record_messages_spec.rb

@@ -7,19 +7,19 @@ module RSpec
         @mock = double("mock").as_null_object
       end
       it "answers false for received_message? when no messages received" do
-        expect(@mock.received_message?(:message)).to be false
+        expect(@mock.received_message?(:message)).to be_falsey
       end
       it "answers true for received_message? when message received" do
         @mock.message
-        expect(@mock.received_message?(:message)).to be true
+        expect(@mock.received_message?(:message)).to be_truthy
       end
       it "answers true for received_message? when message received with correct args" do
         @mock.message 1,2,3
-        expect(@mock.received_message?(:message, 1,2,3)).to be true
+        expect(@mock.received_message?(:message, 1,2,3)).to be_truthy
       end
       it "answers false for received_message? when message received with incorrect args" do
         @mock.message 1,2,3
-        expect(@mock.received_message?(:message, 1,2)).to be false
+        expect(@mock.received_message?(:message, 1,2)).to be_falsey
       end
     end
   end

data/spec/rspec/mocks/serialization_spec.rb

@@ -3,13 +3,12 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe "Serialization of mocked objects" do
-      include_context 'with isolated configuration'
 
       class SerializableObject < Struct.new(:foo, :bar); end
 
       def self.with_yaml_loaded(&block)
         context 'with YAML loaded' do
-          module_eval(&block)
+          module_exec(&block)
         end
       end
 
@@ -18,16 +17,16 @@ module RSpec
           before do
             # We can't really unload yaml, but we can fake it here...
             hide_const("YAML")
-            Struct.class_eval do
+            Struct.class_exec do
               alias __old_to_yaml to_yaml
               undef to_yaml
             end
           end
 
-          module_eval(&block)
+          module_exec(&block)
 
           after do
-            Struct.class_eval do
+            Struct.class_exec do
               alias to_yaml __old_to_yaml
               undef __old_to_yaml
             end
@@ -83,7 +82,6 @@ module RSpec
       end
 
       it 'marshals the same with and without stubbing' do
-        RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = true
         expect { set_stub }.to_not change { Marshal.dump(serializable_object) }
       end
     end

data/spec/rspec/mocks/space_spec.rb

@@ -5,11 +5,10 @@ module RSpec::Mocks
 
     describe "#proxies_of(klass)" do
       let(:space) { Space.new }
-      before { space.outside_example = false }
 
       it 'returns proxies' do
         space.proxy_for("")
-        expect(space.proxies_of(String).map(&:class)).to eq([Proxy])
+        expect(space.proxies_of(String).map(&:class)).to eq([PartialMockProxy])
       end
 
       it 'returns only the proxies whose object is an instance of the given class' do
@@ -21,7 +20,8 @@ module RSpec::Mocks
         parent      = parent_class.new
         child       = child_class.new
 
-        _                 = space.proxy_for(grandparent)
+        space.proxy_for(grandparent)
+
         parent_proxy      = space.proxy_for(parent)
         child_proxy       = space.proxy_for(child)
 

data/spec/rspec/mocks/stub_chain_spec.rb

@@ -37,18 +37,6 @@ module RSpec
       end
 
       context "with two methods in chain" do
-        it "accepts any number of arguments to the stubbed messages" 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
-
-        it "accepts any number of arguments to the stubbed messages with a return value from a hash" do
-          object.stub_chain(:msg1, :msg2 => :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

@@ -37,45 +37,6 @@ module RSpec
         end
       end
 
-      describe "using stub!" do
-        before do
-          allow(RSpec).to receive(:deprecate)
-        end
-
-        it "warns of deprecation" do
-          expect(RSpec).to receive(:deprecate).with("stub!", :replacement => "stub")
-          @instance.stub!(:msg).and_return(:return_value)
-        end
-
-        it "returns the declared value when the message is received" do
-          @instance.stub!(:msg).and_return(:return_value)
-          expect(@instance.msg).to equal(:return_value)
-          verify @instance
-        end
-
-        it "can be used to stub the example context itself (since `stub` returns a test dobule instead)" do
-          stub!(:foo).and_return(5)
-          expect(foo).to eq(5)
-        end
-      end
-
-      describe 'using unstub' do
-        it 'removes the message stub' do
-          @instance.stub(:msg)
-          @instance.unstub(:msg)
-          expect { @instance.msg }.to raise_error NoMethodError
-        end
-      end
-
-      describe 'using unstub!' do
-        it 'removes the message stub but warns about deprecation' do
-          @instance.stub(:msg)
-          RSpec.should_receive(:deprecate).with("unstub!", :replacement => "unstub")
-          @instance.unstub!(:msg)
-          expect { @instance.msg }.to raise_error NoMethodError
-        end
-      end
-
       it "instructs an instance to respond_to the message" do
         @instance.stub(:msg)
         expect(@instance).to respond_to(:msg)
@@ -123,28 +84,47 @@ module RSpec
         end
 
         it "restores existing instance methods" do
-          # See bug reports 8302 adn 7805
+          # See bug reports 8302 and 7805
           @instance.stub(:existing_instance_method) { :stub_value }
           reset @instance
           expect(@instance.existing_instance_method).to eq(:original_value)
         end
 
+        it "restores existing singleton methods with the appropriate context" do
+          klass = Class.new do
+            def self.say_hello
+              @hello if defined?(@hello)
+            end
+          end
+
+          subclass = Class.new(klass)
+
+          subclass.instance_variable_set(:@hello, "Hello")
+          expect(subclass.say_hello).to eq("Hello")
+
+          klass.stub(:say_hello) { "Howdy" }
+          expect(subclass.say_hello).to eq("Howdy")
+
+          reset klass
+          expect(subclass.say_hello).to eq("Hello")
+        end
+
         it "restores existing private instance methods" do
-          # See bug reports 8302 adn 7805
+          # See bug reports 8302 and 7805
           @instance.stub(:existing_private_instance_method) { :stub_value }
           reset @instance
           expect(@instance.send(:existing_private_instance_method)).to eq(:original_value)
         end
 
         it "restores existing class methods" do
-          # See bug reports 8302 adn 7805
+          # See bug reports 8302 and 7805
           @class.stub(:existing_class_method) { :stub_value }
           reset @class
           expect(@class.existing_class_method).to eq(:original_value)
         end
 
         it "restores existing private class methods" do
-          # See bug reports 8302 adn 7805
+          # See bug reports 8302 and 7805
           @class.stub(:existing_private_class_method) { :stub_value }
           reset @class
           expect(@class.send(:existing_private_class_method)).to eq(:original_value)
@@ -285,7 +265,6 @@ module RSpec
       end
 
       it "calculates return value by executing block passed to #and_return" do
-        allow_deprecation
         @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