rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/partial_double_using_mocks_directly_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Mocks
-  describe "PartialDoubleUsingMocksDirectly" do
-    let(:klass) do
-      Class.new do
-        module MethodMissing
-          remove_method :method_missing rescue nil
-          def method_missing(m, *a, &b)
-            if m == :captured_by_method_missing
-              "response generated by method missing"
-            else
-              super(m, *a, &b)
-            end
-          end
-        end
-
-        extend MethodMissing
-        include MethodMissing
-
-        def existing_method
-          :original_value
-        end
-
-      end
-    end
-
-    let(:obj) { klass.new }
-
-    # See http://rubyforge.org/tracker/index.php?func=detail&aid=10263&group_id=797&atid=3149
-    # specify "should clear expectations on verify" do
-    #     obj.should_receive(:msg)
-    #     obj.msg
-    #     verify obj
-    #     expect {
-    #       obj.msg
-    #     }.to raise_error(NoMethodError)
-    #
-    # end
-    it "fails when expected message is not received" do
-      obj.should_receive(:msg)
-      expect {
-        verify obj
-      }.to raise_error(RSpec::Mocks::MockExpectationError)
-    end
-
-    it "fails when message is received with incorrect args" do
-      obj.should_receive(:msg).with(:correct_arg)
-      expect {
-        obj.msg(:incorrect_arg)
-      }.to raise_error(RSpec::Mocks::MockExpectationError)
-      obj.msg(:correct_arg)
-    end
-
-    it "passes when expected message is received" do
-      obj.should_receive(:msg)
-      obj.msg
-      verify obj
-    end
-
-    it "passes when message is received with correct args" do
-      obj.should_receive(:msg).with(:correct_arg)
-      obj.msg(:correct_arg)
-      verify obj
-    end
-
-    it "restores the original method if it existed" do
-      expect(obj.existing_method).to equal(:original_value)
-      obj.should_receive(:existing_method).and_return(:mock_value)
-      expect(obj.existing_method).to equal(:mock_value)
-      verify obj
-      expect(obj.existing_method).to equal(:original_value)
-    end
-
-    context "with an instance method handled by method_missing" do
-      it "restores the original behavior" do
-        expect(obj.captured_by_method_missing).to eq("response generated by method missing")
-        obj.stub(:captured_by_method_missing) { "foo" }
-        expect(obj.captured_by_method_missing).to eq("foo")
-        reset obj
-        expect(obj.captured_by_method_missing).to eq("response generated by method missing")
-      end
-    end
-
-    context "with a class method handled by method_missing" do
-      it "restores the original behavior" do
-        expect(klass.captured_by_method_missing).to eq("response generated by method missing")
-        klass.stub(:captured_by_method_missing) { "foo" }
-        expect(klass.captured_by_method_missing).to eq("foo")
-        reset klass
-        expect(klass.captured_by_method_missing).to eq("response generated by method missing")
-      end
-    end
-  end
-end

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Passing argument matchers" do
-      before(:each) do
-        @double = double('double')
-        Kernel.stub(:warn)
-      end
-
-      after(:each) do
-        verify @double
-      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
-
-        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
-
-        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
-        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
-
-        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
-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
-        expect {
-          verify @double
-        }.to 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
-        expect {
-          @double.do_something
-        }.to 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
-        expect {
-          verify @double
-        }.to 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
-        verify @double
-      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" }
-        expect(@double.to_s).to eq "testing"
-        verify @double
-      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)
-        verify @double
-      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)
-        verify @double
-      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
-        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_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_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_falsey
-      end
-    end
-  end
-end

data/spec/rspec/mocks/serialization_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Serialization of mocked objects" do
-
-      class SerializableObject < Struct.new(:foo, :bar); end
-
-      def self.with_yaml_loaded(&block)
-        context 'with YAML loaded' do
-          module_exec(&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...
-            hide_const("YAML")
-            Struct.class_exec do
-              alias __old_to_yaml to_yaml
-              undef to_yaml
-            end
-          end
-
-          module_exec(&block)
-
-          after do
-            Struct.class_exec 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' }
-            around(:each) { |example| with_isolated_stderr(&example) }
-            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
-          expect(serializable_object).not_to respond_to(:to_yaml)
-          set_stub
-          expect(serializable_object).not_to 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
-    end
-  end
-end

data/spec/rspec/mocks/space_spec.rb

@@ -1,244 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Mocks
-  describe Space do
-    let(:space) { Space.new }
-    let(:dbl_1) { Object.new }
-    let(:dbl_2) { Object.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([PartialDoubleProxy])
-      end
-
-      def create_generations
-        grandparent_class = Class.new
-        parent_class      = Class.new(grandparent_class)
-        child_class       = Class.new(parent_class)
-
-        grandparent = grandparent_class.new
-        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)
-
-        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
-
-      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