rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/example_methods_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe ExampleMethods do
-      it 'does not define private helper methods since it gets included into a ' +
-         'namespace where users define methods and could inadvertently overwrite ' +
-         'them' do
-        expect(ExampleMethods.private_instance_methods).to eq([])
-      end
-    end
-  end
-end

data/spec/rspec/mocks/extensions/marshal_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe Marshal, 'extensions' do
-  # An object that raises when code attempts to dup it.
-  #
-  # Because we manipulate the internals of RSpec::Mocks.space below, we need
-  # an object that simply blows up when #dup is called without using any
-  # partial mocking or stubbing from rspec-mocks itself.
-  class UndupableObject
-    def dup
-      raise NotImplementedError
-    end
-  end
-
-  describe '#dump' do
-    context 'when rspec-mocks has been fully initialized' do
-      it 'duplicates objects with stubbed or mocked implementations before serialization' do
-        obj = double(:foo => "bar")
-
-        serialized = Marshal.dump(obj)
-        expect(Marshal.load(serialized)).to be_an(obj.class)
-      end
-
-      it 'does not duplicate other objects before serialization' do
-        obj = UndupableObject.new
-
-        serialized = Marshal.dump(obj)
-        expect(Marshal.load(serialized)).to be_an(UndupableObject)
-      end
-
-      it 'does not duplicate nil before serialization' do
-        serialized = Marshal.dump(nil)
-        expect(Marshal.load(serialized)).to be_nil
-      end
-    end
-
-    context 'outside the per-test lifecycle' do
-      def outside_per_test_lifecycle
-        RSpec::Mocks.teardown
-        yield
-      ensure
-        RSpec::Mocks.setup
-      end
-
-      it 'does not duplicate the object before serialization' do
-        obj = UndupableObject.new
-        outside_per_test_lifecycle do
-          serialized = Marshal.dump(obj)
-          expect(Marshal.load(serialized)).to be_an(UndupableObject)
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -1,184 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "failing MockArgumentMatchers" do
-      before(:each) do
-        @double = double("double")
-        @reporter = double("reporter").as_null_object
-      end
-
-      after(:each) do
-        reset @double
-      end
-
-      it "rejects non boolean" do
-        @double.should_receive(:random_call).with(boolean())
-        expect do
-          @double.random_call("false")
-        end.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "rejects non numeric" do
-        @double.should_receive(:random_call).with(an_instance_of(Numeric))
-        expect do
-          @double.random_call("1")
-        end.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "rejects non string" do
-        @double.should_receive(:random_call).with(an_instance_of(String))
-        expect do
-          @double.random_call(123)
-        end.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "rejects goose when expecting a duck" do
-        @double.should_receive(:random_call).with(duck_type(:abs, :div))
-        expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails if regexp does not match submitted string" do
-        @double.should_receive(:random_call).with(/bcd/)
-        expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails if regexp does not match submitted regexp" do
-        @double.should_receive(:random_call).with(/bcd/)
-        expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails for a hash w/ wrong values" do
-        @double.should_receive(:random_call).with(:a => "b", :c => "d")
-        expect do
-          @double.random_call(:a => "b", :c => "e")
-        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
-      end
-
-      it "fails for a hash w/ wrong keys" do
-        @double.should_receive(:random_call).with(:a => "b", :c => "d")
-        expect do
-          @double.random_call("a" => "b", "c" => "d")
-        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
-      end
-
-      it "matches against a Matcher" do
-        # This spec is generating warnings on 1.8.7, not sure why so
-        # this does with_isolated_stderr to kill them. @samphippen 3rd Jan 2013.
-        expect do
-          @double.should_receive(:msg).with(equal(3))
-          with_isolated_stderr { @double.msg(37) }
-        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
-      end
-
-      it "fails no_args with one arg" do
-        expect do
-          @double.should_receive(:msg).with(no_args)
-          @double.msg(37)
-        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
-      end
-
-      it "fails hash_including with missing key" do
-         expect do
-           @double.should_receive(:msg).with(hash_including(:a => 1))
-           @double.msg({})
-         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
-      end
-
-      it "fails array_including when args aren't array" do
-         expect do
-           @double.should_receive(:msg).with(array_including(1,2,3))
-           @double.msg(1,2,3)
-         end.to raise_error(/array_including\(1,2,3\)/)
-      end
-
-      it "fails array_including when arg doesn't contain all elements" do
-         expect do
-           @double.should_receive(:msg).with(array_including(1,2,3))
-           @double.msg(1,2)
-         end.to raise_error(/array_including\(1,2,3\)/)
-      end
-
-      it "fails with zero arguments" do
-        expect do
-          @double.should_receive(:msg).with {|arg| expect(arg).to eq :received }
-        end.to raise_error(ArgumentError, /must have at least one argument/)
-      end
-
-      it "fails when given an arbitrary object that returns false from #===" do
-        matcher = double
-        matcher.should_receive(:===).with(4).at_least(:once).and_return(false)
-
-        @double.should_receive(:foo).with(matcher)
-
-        expect {
-          @double.foo(4)
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails with sensible message when args respond to #description" do
-        arg = Class.new do
-          def description
-          end
-
-          def inspect
-            "my_thing"
-          end
-        end.new
-
-        expect do
-          @double.should_receive(:msg).with(3)
-          @double.msg arg
-        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (3)\n       got: (my_thing)")
-      end
-
-      it "fails with sensible message when arg#description is nil" do
-        arg = Class.new do
-          def description
-          end
-
-          def inspect
-            "my_thing"
-          end
-        end.new
-
-        expect do
-          @double.should_receive(:msg).with(arg)
-          @double.msg 3
-        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (my_thing)\n       got: (3)")
-      end
-
-      it "fails with sensible message when arg#description is blank" do
-        arg = Class.new do
-          def description
-            ""
-          end
-
-          def inspect
-            "my_thing"
-          end
-        end.new
-
-        expect do
-          @double.should_receive(:msg).with(arg)
-          @double.msg 3
-        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (my_thing)\n       got: (3)")
-      end
-
-      it "fails a class against an unrelated class" do
-        @double.should_receive(:foo).with(Fixnum)
-        expect {
-          @double.foo(Hash)
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails a class against an object of a different type" do
-        @double.should_receive(:foo).with(Fixnum)
-
-        expect {
-          @double.foo(3.2)
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/hash_excluding_matcher_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      describe HashExcludingMatcher do
-
-        it "describes itself properly" do
-          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
-        end
-
-        describe "passing" do
-          it "matches a hash without the specified key" do
-            expect(hash_not_including(:c)).to be === {:a => 1, :b => 2}
-          end
-
-          it "matches a hash with the specified key, but different value" do
-            expect(hash_not_including(:b => 3)).to be === {:a => 1, :b => 2}
-          end
-
-          it "matches a hash without the specified key, given as anything()" do
-            expect(hash_not_including(:c => anything)).to be === {:a => 1, :b => 2}
-          end
-
-          it "matches an empty hash" do
-            expect(hash_not_including(:a)).to be === {}
-          end
-
-          it "matches a hash without any of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).to be === { :d => 7 }
-          end
-
-        end
-
-        describe "failing" do
-          it "does not match a non-hash" do
-            expect(hash_not_including(:a => 1)).not_to be === 1
-          end
-
-          it "does not match a hash with a specified key" do
-            expect(hash_not_including(:b)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with the specified key/value pair" do
-            expect(hash_not_including(:b => 2)).not_to be === { :a => 1, :b => 2 }
-          end
-
-          it "does not match a hash with the specified key" do
-            expect(hash_not_including(:a, :b => 3)).not_to be === { :a => 1, :b => 2 }
-          end
-
-          it "does not match a hash with one of the specified keys" do
-            expect(hash_not_including(:a, :b)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with some of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).not_to be === { :a => 1, :b => 2 }
-          end
-
-          it "does not match a hash with one key/value pair included" do
-            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to be === { :d => 7 }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      describe HashIncludingMatcher do
-
-        it "describes itself properly" do
-          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
-        end
-
-        describe "passing" do
-          it "matches the same hash" do
-            expect(hash_including(:a => 1)).to be === {:a => 1}
-          end
-
-          it "matches a hash with extra stuff" do
-            expect(hash_including(:a => 1)).to be === {:a => 1, :b => 2}
-          end
-
-          describe "when matching against other matchers" do
-            it "matches an int against anything()" do
-              expect(hash_including(:a => anything, :b => 2)).to be === {:a => 1, :b => 2}
-            end
-
-            it "matches a string against anything()" do
-              expect(hash_including(:a => anything, :b => 2)).to be === {:a => "1", :b => 2}
-            end
-
-            it 'can match against arbitrary objects that implement #===' do
-              expect(hash_including(:a => /foo/)).to be === { :a => "foobar" }
-            end
-          end
-
-          describe "when passed only keys or keys mixed with key/value pairs" do
-            it "matches if the key is present" do
-              expect(hash_including(:a)).to be === {:a => 1, :b => 2}
-            end
-
-            it "matches if more keys are present" do
-              expect(hash_including(:a, :b)).to be === {:a => 1, :b => 2, :c => 3}
-            end
-
-            it "matches a string against a given key" do
-              expect(hash_including(:a)).to be === {:a => "1", :b => 2}
-            end
-
-            it "matches if passed one key and one key/value pair" do
-              expect(hash_including(:a, :b => 2)).to be === {:a => 1, :b => 2}
-            end
-
-            it "matches if passed many keys and one key/value pair" do
-              expect(hash_including(:a, :b, :c => 3)).to be === {:a => 1, :b => 2, :c => 3, :d => 4}
-            end
-
-            it "matches if passed many keys and many key/value pairs" do
-              expect(hash_including(:a, :b, :c => 3, :e => 5)).to be === {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
-            end
-          end
-        end
-
-        describe "failing" do
-          it "does not match a non-hash" do
-            expect(hash_including(:a => 1)).not_to be === 1
-          end
-
-          it "does not match a hash with a missing key" do
-            expect(hash_including(:a => 1)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with a missing key" do
-            expect(hash_including(:a)).not_to be === { :b => 2 }
-          end
-
-          it "does not match an empty hash with a given key" do
-            expect(hash_including(:a)).not_to be === {}
-          end
-
-          it "does not match a hash with a missing key when one pair is matching" do
-            expect(hash_including(:a, :b => 2)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with an incorrect value" do
-            expect(hash_including(:a => 1, :b => 2)).not_to be === { :a => 1, :b => 3 }
-          end
-
-          it "does not match when values are nil but keys are different" do
-            expect(hash_including(:a => nil)).not_to be === { :b => nil }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/instance_method_stasher_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe InstanceMethodStasher do
-      class ExampleClass
-        def hello
-          :hello_defined_on_class
-        end
-      end
-
-      def singleton_class_for(obj)
-        class << obj; self; end
-      end
-
-      def stasher_for(obj, method_name)
-        InstanceMethodStasher.new(obj, method_name)
-      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 = stasher_for(obj, :hello)
-        stashed_method.stash
-
-        with_isolated_stderr { 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 = stasher_for(obj, :hello)
-        stashed_method.stash
-
-        with_isolated_stderr { 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 = stasher_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
-
-      it "does not unnecessarily create obfuscated aliased methods", :if => (RUBY_VERSION.to_f > 1.8) do
-        obj = Object.new
-        def obj.hello; :hello_defined_on_singleton_class; end;
-
-        stashed_method = stasher_for(obj, :hello)
-
-        expect {
-          stashed_method.stash
-        }.not_to change { obj.methods.count }
-
-        expect(obj.methods.grep(/rspec/)).to eq([])
-      end
-    end
-  end
-end