rspec-mocks 2.11.3 → 3.11.1

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Methods do
-      before(:each) do
-        @double = double('double')
-        Kernel.stub(:warn)
-      end
-
-      after(:each) do
-        @double.rspec_verify
-      end
-
-      context "handling argument matchers" do
-        it "accepts true as boolean()" do
-          @double.should_receive(:random_call).with(boolean())
-          @double.random_call(true)
-        end
-
-        it "accepts false as boolean()" do
-          @double.should_receive(:random_call).with(boolean())
-          @double.random_call(false)
-        end
-
-        it "accepts fixnum as kind_of(Numeric)" do
-          @double.should_receive(:random_call).with(kind_of(Numeric))
-          @double.random_call(1)
-        end
-
-        it "accepts float as an_instance_of(Numeric)" do
-          @double.should_receive(:random_call).with(kind_of(Numeric))
-          @double.random_call(1.5)
-        end
-
-        it "accepts fixnum as instance_of(Fixnum)" do
-          @double.should_receive(:random_call).with(instance_of(Fixnum))
-          @double.random_call(1)
-        end
-
-        it "does NOT accept fixnum as instance_of(Numeric)" do
-          @double.should_not_receive(:random_call).with(instance_of(Numeric))
-          @double.random_call(1)
-        end
-
-        it "does NOT accept float as instance_of(Numeric)" do
-          @double.should_not_receive(:random_call).with(instance_of(Numeric))
-          @double.random_call(1.5)
-        end
-
-        it "accepts string as anything()" do
-          @double.should_receive(:random_call).with("a", anything(), "c")
-          @double.random_call("a", "whatever", "c")
-        end
-
-        it "matches duck type with one method" do
-          @double.should_receive(:random_call).with(duck_type(:length))
-          @double.random_call([])
-        end
-
-        it "matches duck type with two methods" do
-          @double.should_receive(:random_call).with(duck_type(:abs, :div))
-          @double.random_call(1)
-        end
-
-        it "matches no args against any_args()" do
-          @double.should_receive(:random_call).with(any_args)
-          @double.random_call()
-        end
-
-        it "matches one arg against any_args()" do
-          @double.should_receive(:random_call).with(any_args)
-          @double.random_call("a string")
-        end
-
-        it "matches no args against no_args()" do
-          @double.should_receive(:random_call).with(no_args)
-          @double.random_call()
-        end
-
-        it "matches hash with hash_including same hash" do
-          @double.should_receive(:random_call).with(hash_including(:a => 1))
-          @double.random_call(:a => 1)
-        end
-      end
-
-      context "handling block matchers" do
-        it "matches arguments against RSpec expectations" do
-          @double.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
-            arg1.should eq 5
-            arg2.should have_at_least(3).characters
-            arg2.should have_at_most(10).characters
-            arr.map {|i| i * 2}.should eq [2,4,6]
-            rest.should 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)
-          eval_count.should eq(1)
-        end
-      end
-
-      context "handling non-matcher arguments" do
-        it "matches non special symbol (can be removed when deprecated symbols are removed)" do
-          @double.should_receive(:random_call).with(:some_symbol)
-          @double.random_call(:some_symbol)
-        end
-
-        it "matches string against regexp" do
-          @double.should_receive(:random_call).with(/bcd/)
-          @double.random_call("abcde")
-        end
-
-        it "matches regexp against regexp" do
-          @double.should_receive(:random_call).with(/bcd/)
-          @double.random_call(/bcd/)
-        end
-
-        it "matches against a hash submitted and received by value" do
-          @double.should_receive(:random_call).with(:a => "a", :b => "b")
-          @double.random_call(:a => "a", :b => "b")
-        end
-
-        it "matches against a hash submitted by reference and received by value" do
-          opts = {:a => "a", :b => "b"}
-          @double.should_receive(:random_call).with(opts)
-          @double.random_call(:a => "a", :b => "b")
-        end
-
-        it "matches against a hash submitted by value and received by reference" do
-          opts = {:a => "a", :b => "b"}
-          @double.should_receive(:random_call).with(:a => "a", :b => "b")
-          @double.random_call(opts)
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/precise_counts_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "PreciseCounts" do
-      before(:each) do
-        @double = double("test double")
-      end
-
-      it "fails when exactly n times method is called less than n times" do
-        @double.should_receive(:do_something).exactly(3).times
-        @double.do_something
-        @double.do_something
-        lambda do
-          @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails fast when exactly n times method is called more than n times" do
-        @double.should_receive(:do_something).exactly(3).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        lambda do
-          @double.do_something
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when exactly n times method is never called" do
-        @double.should_receive(:do_something).exactly(3).times
-        lambda do
-          @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "passes if exactly n times method is called exactly n times" do
-        @double.should_receive(:do_something).exactly(3).times
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.rspec_verify
-      end
-
-      it "returns the value given by a block when the exactly once method is called" do
-        @double.should_receive(:to_s).exactly(:once) { "testing" }
-        @double.to_s.should eq "testing"
-        @double.rspec_verify
-      end
-
-      it "passes mutiple calls with different args" do
-        @double.should_receive(:do_something).once.with(1)
-        @double.should_receive(:do_something).once.with(2)
-        @double.do_something(1)
-        @double.do_something(2)
-        @double.rspec_verify
-      end
-
-      it "passes multiple calls with different args and counts" do
-        @double.should_receive(:do_something).twice.with(1)
-        @double.should_receive(:do_something).once.with(2)
-        @double.do_something(1)
-        @double.do_something(2)
-        @double.do_something(1)
-        @double.rspec_verify
-      end
-    end
-  end
-end

data/spec/rspec/mocks/record_messages_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "a mock" do
-      before(:each) do
-        @mock = double("mock").as_null_object
-      end
-      it "answers false for received_message? when no messages received" do
-        @mock.received_message?(:message).should be_false
-      end
-      it "answers true for received_message? when message received" do
-        @mock.message
-        @mock.received_message?(:message).should be_true
-      end
-      it "answers true for received_message? when message received with correct args" do
-        @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2,3).should be_true
-      end
-      it "answers false for received_message? when message received with incorrect args" do
-        @mock.message 1,2,3
-        @mock.received_message?(:message, 1,2).should be_false
-      end
-    end
-  end
-end

data/spec/rspec/mocks/serialization_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Serialization do
-
-      class SerializableObject < Struct.new(:foo, :bar); end
-
-      class SerializableMockProxy
-        attr_reader :mock_proxy
-
-        def initialize(mock_proxy)
-          @mock_proxy = mock_proxy
-        end
-
-        def ==(other)
-          other.class == self.class && other.mock_proxy == mock_proxy
-        end
-      end
-
-      def self.with_yaml_loaded(&block)
-        context 'with YAML loaded' do
-          module_eval(&block)
-        end
-      end
-
-      def self.without_yaml_loaded(&block)
-        context 'without YAML loaded' do
-          before do
-            # We can't really unload yaml, but we can fake it here...
-            @orig_yaml_constant = Object.send(:remove_const, :YAML)
-            Struct.class_eval do
-              alias __old_to_yaml to_yaml
-              undef to_yaml
-            end
-          end
-
-          module_eval(&block)
-
-          after do
-            Object.const_set(:YAML, @orig_yaml_constant)
-            Struct.class_eval do
-              alias to_yaml __old_to_yaml
-              undef __old_to_yaml
-            end
-          end
-        end
-      end
-
-      let(:serializable_object) { RSpec::Mocks::SerializableObject.new(7, "something") }
-
-      def set_stub
-        serializable_object.stub(:bazz => 5)
-      end
-
-      shared_examples_for 'normal YAML serialization' do
-        it 'serializes to yaml the same with and without stubbing, using #to_yaml' do
-          expect { set_stub }.to_not change { serializable_object.to_yaml }
-        end
-
-        it 'serializes to yaml the same with and without stubbing, using YAML.dump' do
-          expect { set_stub }.to_not change { ::YAML.dump(serializable_object) }
-        end
-      end
-
-      with_yaml_loaded do
-        compiled_with_psych = begin
-          require 'psych'
-          true
-        rescue LoadError
-          false
-        end
-
-        if compiled_with_psych
-          context 'using Syck as the YAML engine' do
-            before(:each) { ::YAML::ENGINE.yamler = 'syck' }
-            it_behaves_like 'normal YAML serialization'
-          end
-
-          context 'using Psych as the YAML engine' do
-            before(:each) { ::YAML::ENGINE.yamler = 'psych' }
-            it_behaves_like 'normal YAML serialization'
-          end
-        else
-          it_behaves_like 'normal YAML serialization'
-        end
-      end
-
-      without_yaml_loaded do
-        it 'does not add #to_yaml to the stubbed object' do
-          serializable_object.should_not respond_to(:to_yaml)
-          set_stub
-          serializable_object.should_not respond_to(:to_yaml)
-        end
-      end
-
-      it 'marshals the same with and without stubbing' do
-        expect { set_stub }.to_not change { Marshal.dump(serializable_object) }
-      end
-
-      describe "an object that has its own mock_proxy instance variable" do
-        let(:serializable_object) { RSpec::Mocks::SerializableMockProxy.new(:my_mock_proxy) }
-
-        it 'does not interfere with its marshalling' do
-          marshalled_copy = Marshal.load(Marshal.dump(serializable_object))
-          marshalled_copy.should eq serializable_object
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/stash_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-
-    describe "only stashing the original method" do
-      let(:klass) do
-        Class.new do
-          def self.foo(arg)
-            :original_value
-          end
-        end
-      end
-      it "keeps the original method intact after multiple expectations are added on the same method" do
-        klass.should_receive(:foo).with(:fizbaz).and_return(:wowwow)
-        klass.should_receive(:foo).with(:bazbar).and_return(:okay)
-
-        klass.foo(:fizbaz)
-        klass.foo(:bazbar)
-        klass.rspec_verify
-
-        klass.rspec_reset
-        klass.foo(:yeah).should equal(:original_value)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/stashed_instance_method_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-describe StashedInstanceMethod do
-  class ExampleClass
-    def hello
-      :hello_defined_on_class
-    end
-  end
-
-  def singleton_class_for(obj)
-    class << obj; self; end
-  end
-
-  it "stashes the current implementation of an instance method so it can be temporarily replaced" do
-    obj = Object.new
-    def obj.hello; :hello_defined_on_singleton_class; end;
-
-    stashed_method = StashedInstanceMethod.new(singleton_class_for(obj), :hello)
-    stashed_method.stash
-
-    def obj.hello; :overridden_hello; end
-    expect(obj.hello).to eql :overridden_hello
-
-    stashed_method.restore
-    expect(obj.hello).to eql :hello_defined_on_singleton_class
-  end
-
-  it "stashes private instance methods" do
-    obj = Object.new
-    def obj.hello; :hello_defined_on_singleton_class; end;
-    singleton_class_for(obj).__send__(:private, :hello)
-
-    stashed_method = StashedInstanceMethod.new(singleton_class_for(obj), :hello)
-    stashed_method.stash
-
-    def obj.hello; :overridden_hello; end
-    stashed_method.restore
-    expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
-  end
-
-  it "only stashes methods directly defined on the given class, not its ancestors" do
-    obj = ExampleClass.new
-
-    stashed_method = StashedInstanceMethod.new(singleton_class_for(obj), :hello)
-    stashed_method.stash
-
-    def obj.hello; :overridden_hello; end;
-    expect(obj.hello).to eql :overridden_hello
-
-    stashed_method.restore
-    expect(obj.hello).to eql :overridden_hello
-  end
-end

data/spec/rspec/mocks/stub_chain_spec.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "A chained method stub" do
-      let(:object) { Object.new }
-
-      context "with one method in chain" do
-        context "using and_return" do
-          it "returns expected value from chaining only one method call" do
-            object.stub_chain(:msg1).and_return(:return_value)
-            object.msg1.should equal(:return_value)
-          end
-        end
-
-        context "using a block" do
-          it "returns the correct value" do
-            object.stub_chain(:msg1) { :return_value }
-            object.msg1.should equal(:return_value)
-          end
-        end
-
-        context "using a hash" do
-          it "returns the value of the key/value pair" do
-            object.stub_chain(:msg1 => :return_value)
-            object.msg1.should equal(:return_value)
-          end
-        end
-      end
-
-      context "with two methods in chain" do
-        context "using and_return" do
-          it "returns expected value from chaining two method calls" do
-            object.stub_chain(:msg1, :msg2).and_return(:return_value)
-            object.msg1.msg2.should equal(:return_value)
-          end
-        end
-
-        context "using a block" do
-          it "returns the correct value" do
-            object.stub_chain(:msg1, :msg2) { :return_value }
-            object.msg1.msg2.should equal(:return_value)
-          end
-        end
-
-        context "using a hash" do
-          it "returns the value of the key/value pair" do
-            object.stub_chain(:msg1, :msg2 => :return_value)
-            object.msg1.msg2.should equal(:return_value)
-          end
-        end
-      end
-
-      context "with four methods in chain" do
-        context "using and_return" do
-          it "returns expected value from chaining two method calls" do
-            object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
-          end
-        end
-
-        context "using a block" do
-          it "returns the correct value" do
-            object.stub_chain(:msg1, :msg2, :msg3, :msg4) { :return_value }
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
-          end
-        end
-
-        context "using a hash" do
-          it "returns the value of the key/value pair" do
-            object.stub_chain(:msg1, :msg2, :msg3, :msg4 => :return_value)
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
-          end
-        end
-
-        context "using a hash with a string key" do
-          it "returns the value of the key/value pair" do
-            object.stub_chain("msg1.msg2.msg3.msg4" => :return_value)
-            object.msg1.msg2.msg3.msg4.should equal(:return_value)
-          end
-        end
-      end
-
-      it "returns expected value from chaining four method calls" do
-        object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
-        object.msg1.msg2.msg3.msg4.should equal(:return_value)
-      end
-
-      context "with messages shared across multiple chains" do
-        context "using and_return" do
-          context "starting with the same message" do
-            it "returns expected value" do
-              object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
-              object.stub_chain(:msg1, :msg2, :msg4).and_return(:second)
-
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg1.msg2.msg4.should equal(:second)
-            end
-          end
-
-          context "starting with the different messages" do
-            it "returns expected value" do
-              object.stub_chain(:msg1, :msg2, :msg3).and_return(:first)
-              object.stub_chain(:msg4, :msg2, :msg3).and_return(:second)
-
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg4.msg2.msg3.should equal(:second)
-            end
-          end
-        end
-
-        context "using => value" do
-          context "starting with the same message" do
-            it "returns expected value" do
-              object.stub_chain(:msg1, :msg2, :msg3 => :first)
-              object.stub_chain(:msg1, :msg2, :msg4 => :second)
-
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg1.msg2.msg4.should equal(:second)
-            end
-          end
-
-          context "starting with different messages" do
-            it "returns expected value" do
-              object.stub_chain(:msg1, :msg2, :msg3 => :first)
-              object.stub_chain(:msg4, :msg2, :msg3 => :second)
-
-              object.msg1.msg2.msg3.should equal(:first)
-              object.msg4.msg2.msg3.should equal(:second)
-            end
-          end
-        end
-      end
-
-      it "returns expected value when chain is a dot separated string, like stub_chain('msg1.msg2.msg3')" do
-        object.stub_chain("msg1.msg2.msg3").and_return(:return_value)
-        object.msg1.msg2.msg3.should equal(:return_value)
-      end
-
-      it "returns expected value from two chains with shared messages at the beginning" do
-        object.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
-        object.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
-
-        object.msg1.msg2.msg3.msg4.should equal(:first)
-        object.msg1.msg2.msg3.msg5.should equal(:second)
-      end
-
-      it "handles private instance methods (like Object#select) in the middle of a chain" do
-        object.stub_chain(:msg1, :select, :msg3 => 'answer')
-        expect(object.msg1.select.msg3).to eq 'answer'
-      end
-    end
-  end
-end