rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "an expectation set on nil" do
-      it "issues a warning with file and line number information" do
-        expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in .+)?. Use allow_message_expectations_on_nil to disable warnings.%
-        Kernel.should_receive(:warn).with(expected_warning)
-
-        nil.should_receive(:foo)
-        nil.foo
-      end
-
-      it "issues a warning when the expectation is negative" do
-        Kernel.should_receive(:warn)
-
-        nil.should_not_receive(:foo)
-      end
-
-      it "does not issue a warning when expectations are set to be allowed" do
-        allow_message_expectations_on_nil
-        Kernel.should_not_receive(:warn)
-
-        nil.should_receive(:foo)
-        nil.should_not_receive(:bar)
-        nil.foo
-      end
-
-      it 'does not call #nil? on a double extra times' do
-        dbl = double
-        dbl.should_receive(:nil?).once.and_return(false)
-        dbl.nil?
-      end
-    end
-
-    describe "#allow_message_expectations_on_nil" do
-      it "does not affect subsequent examples" do
-        allow_message_expectations_on_nil
-        RSpec::Mocks.teardown
-        RSpec::Mocks.setup
-        Kernel.should_receive(:warn)
-        nil.should_receive(:foo)
-        nil.foo
-      end
-
-      it 'doesnt error when marshalled' do
-        allow_message_expectations_on_nil
-        expect(Marshal.dump(nil)).to eq Marshal.dump_without_mocks(nil)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "a double _not_ acting as a null object" do
-      before(:each) do
-        @double = double('non-null object')
-      end
-
-      it "says it does not respond to messages it doesn't understand" do
-        expect(@double).not_to respond_to(:foo)
-      end
-
-      it "says it responds to messages it does understand" do
-        @double.stub(:foo)
-        expect(@double).to respond_to(:foo)
-      end
-
-      it "raises an error when interpolated in a string as an integer" do
-        # Not sure why, but 1.9.2 (but not JRuby --1.9) raises a different
-        # error than 1.8.7 and 1.9.3...
-        expected_error = (RUBY_VERSION == '1.9.2' && RUBY_PLATFORM !~ /java/) ?
-                         RSpec::Mocks::MockExpectationError :
-                         TypeError
-
-        expect { "%i" % @double }.to raise_error(expected_error)
-      end
-    end
-
-    describe "a double acting as a null object" do
-      before(:each) do
-        @double = double('null object').as_null_object
-      end
-
-      it "says it responds to everything" do
-        expect(@double).to respond_to(:any_message_it_gets)
-      end
-
-      it "allows explicit stubs" do
-        @double.stub(:foo) { "bar" }
-        expect(@double.foo).to eq("bar")
-      end
-
-      it "allows explicit expectation" do
-        @double.should_receive(:something)
-        @double.something
-      end
-
-      it 'continues to return self from an explicit expectation' do
-        @double.should_receive(:bar)
-        expect(@double.foo.bar).to be(@double)
-      end
-
-      it 'returns an explicitly stubbed value from an expectation with no implementation' do
-        @double.stub(:foo => "bar")
-        @double.should_receive(:foo)
-        expect(@double.foo).to eq("bar")
-      end
-
-      it "fails verification when explicit exception not met" do
-        expect {
-          @double.should_receive(:something)
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "ignores unexpected methods" do
-        @double.random_call("a", "d", "c")
-        verify @double
-      end
-
-      it 'allows unexpected message sends using `send`' do
-        val = @double.send(:foo).send(:bar)
-        expect(val).to equal(@double)
-      end
-
-      it 'allows unexpected message sends using `send`' do
-        val = @double.__send__(:foo).__send__(:bar)
-        expect(val).to equal(@double)
-      end
-
-      it "allows expected message with different args first" do
-        @double.should_receive(:message).with(:expected_arg)
-        @double.message(:unexpected_arg)
-        @double.message(:expected_arg)
-      end
-
-      it "allows expected message with different args second" do
-        @double.should_receive(:message).with(:expected_arg)
-        @double.message(:expected_arg)
-        @double.message(:unexpected_arg)
-      end
-
-      it "can be interpolated in a string as an integer" do
-        # This form of string interpolation calls
-        # @double.to_int.to_int.to_int...etc until it gets an integer,
-        # and thus gets stuck in an infinite loop unless our double
-        # returns an int value from #to_int.
-        expect(("%i" % @double)).to eq("0")
-      end
-
-      it "does not allow null objects to be used outside of examples" do
-        RSpec::Mocks.teardown
-
-        expect { @double.some.long.message.chain }.to raise_error(RSpec::Mocks::OutsideOfExampleError)
-        expect { @double.as_null_object }.to raise_error(RSpec::Mocks::OutsideOfExampleError)
-      end
-    end
-
-    describe "#as_null_object" do
-      it "sets the object to null_object" do
-        obj = double('anything').as_null_object
-        expect(obj).to be_null_object
-      end
-    end
-
-    describe "#null_object?" do
-      it "defaults to false" do
-        obj = double('anything')
-        expect(obj).not_to be_null_object
-      end
-    end
-
-    describe "when using the :expect syntax" do
-      include_context "with syntax", :expect
-
-      it 'still supports null object doubles' do
-        obj = double("foo").as_null_object
-        expect(obj.foo.bar.bazz).to be(obj)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/once_counts_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "#once" do
-      before(:each) do
-        @double = double
-      end
-
-      it "passes when called once" do
-        @double.should_receive(:do_something).once
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when called once with specified args" do
-        @double.should_receive(:do_something).once.with("a", "b", "c")
-        @double.do_something("a", "b", "c")
-        verify @double
-      end
-
-      it "passes when called once with unspecified args" do
-        @double.should_receive(:do_something).once
-        @double.do_something("a", "b", "c")
-        verify @double
-      end
-
-      it "fails when called with wrong args" do
-        @double.should_receive(:do_something).once.with("a", "b", "c")
-        expect {
-          @double.do_something("d", "e", "f")
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-        reset @double
-      end
-
-      it "fails fast when called twice" do
-        @double.should_receive(:do_something).once
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "fails when not called" do
-        @double.should_receive(:do_something).once
-        expect {
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/options_hash_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    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.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
-          verify mock
-        rescue Exception => e
-        ensure
-          expect(e.backtrace.to_s).to match(/\/path\/to\/blah.ext:37/m)
-        end
-      end
-
-      it "uses the message supplied with :message" do
-        expect {
-          m = RSpec::Mocks::Double.new("a mock")
-          m.should_receive(:message, :message => "recebi nada")
-          verify m
-        }.to raise_error("recebi nada")
-      end
-
-      it "uses the message supplied with :message after a similar stub" do
-        expect {
-          m = RSpec::Mocks::Double.new("a mock")
-          m.stub(:message)
-          m.should_receive(:message, :message => "from mock")
-          verify m
-        }.to raise_error("from mock")
-      end
-    end
-  end
-end

data/spec/rspec/mocks/order_group_spec.rb

@@ -1,27 +0,0 @@
-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_double_spec.rb

@@ -1,308 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "A partial double" do
-      let(:object) { Object.new }
-
-      it "names the class in the failure message" do
-        object.should_receive(:foo)
-        expect do
-          verify object
-        end.to raise_error(RSpec::Mocks::MockExpectationError, /\(#<Object:.*>\).foo/)
-      end
-
-      it "names the class in the failure message when expectation is on class" do
-        Object.should_receive(:foo)
-        expect {
-          verify Object
-        }.to raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
-      end
-
-      it "does not conflict with @options in the object" do
-        object.instance_exec { @options = Object.new }
-        object.should_receive(:blah)
-        object.blah
-      end
-
-      it "should_not_receive mocks out the method" do
-        object.should_not_receive(:fuhbar)
-        expect {
-          object.fuhbar
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          /expected\: 0 times with any arguments\n    received\: 1 time/
-        )
-      end
-
-      it "should_not_receive returns a negative message expectation" do
-        expect(object.should_not_receive(:foobar)).to be_negative
-      end
-
-      it "should_receive mocks out the method" do
-        object.should_receive(:foobar).with(:test_param).and_return(1)
-        expect(object.foobar(:test_param)).to equal(1)
-      end
-
-      it "should_receive handles a hash" do
-        object.should_receive(:foobar).with(:key => "value").and_return(1)
-        expect(object.foobar(:key => "value")).to equal(1)
-      end
-
-      it "should_receive handles an inner hash" do
-        hash = {:a => {:key => "value"}}
-        object.should_receive(:foobar).with(:key => "value").and_return(1)
-        expect(object.foobar(hash[:a])).to equal(1)
-      end
-
-      it "should_receive returns a positive message expectation" do
-        expect(object.should_receive(:foobar)).not_to be_negative
-        object.foobar
-      end
-
-      it "should_receive verifies method was called" do
-        object.should_receive(:foobar).with(:test_param).and_return(1)
-        expect {
-          verify object
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "should_receive also takes a String argument" do
-        object.should_receive('foobar')
-        object.foobar
-      end
-
-      it "should_not_receive also takes a String argument" do
-        object.should_not_receive('foobar')
-        expect {
-          object.foobar
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "uses reports nil in the error message" do
-        allow_message_expectations_on_nil
-
-        _nil = nil
-        _nil.should_receive(:foobar)
-        expect {
-          verify _nil
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(nil).foobar(any args)\n    expected: 1 time with any arguments\n    received: 0 times with any arguments|
-        )
-      end
-
-      it "includes the class name in the error when mocking a class method that is called an extra time with the wrong args" do
-        klass = Class.new do
-          def self.inspect
-            "MyClass"
-          end
-        end
-
-        klass.should_receive(:bar).with(1)
-        klass.bar(1)
-
-        expect {
-          klass.bar(2)
-        }.to raise_error(RSpec::Mocks::MockExpectationError, /MyClass/)
-      end
-    end
-
-    describe "Using a partial mock on a proxy object", :if => defined?(::BasicObject) do
-      let(:proxy_class) do
-        Class.new(::BasicObject) do
-          def initialize(target)
-            @target = target
-          end
-
-          def proxied?
-            true
-          end
-
-          def method_missing(*a)
-            @target.send(*a)
-          end
-        end
-      end
-
-      let(:wrapped_object) { Object.new }
-      let(:proxy) { proxy_class.new(wrapped_object) }
-
-      it 'works properly' do
-        proxy.should_receive(:proxied?).and_return(false)
-        expect(proxy).not_to be_proxied
-      end
-
-      it 'does not confuse the proxy and the proxied object' do
-        proxy.stub(:foo).and_return(:proxy_foo)
-        wrapped_object.stub(:foo).and_return(:wrapped_foo)
-
-        expect(proxy.foo).to eq(:proxy_foo)
-        expect(wrapped_object.foo).to eq(:wrapped_foo)
-      end
-    end
-
-    describe "Partially mocking an object that defines ==, after another mock has been defined" do
-      before(:each) do
-        double("existing mock", :foo => :foo)
-      end
-
-      let(:klass) do
-        Class.new do
-          attr_reader :val
-          def initialize(val)
-            @val = val
-          end
-
-          def ==(other)
-            @val == other.val
-          end
-        end
-      end
-
-      it "does not raise an error when stubbing the object" do
-        o = klass.new :foo
-        expect { o.stub(:bar) }.not_to raise_error
-      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
-          def public_method
-            private_method
-            protected_method
-          end
-          protected
-          def protected_method; end
-          private
-          def private_method; end
-        end
-      end
-
-      let(:object) { klass.new }
-
-      it 'keeps public methods public' do
-        object.should_receive(:public_method)
-        expect(object.public_methods).to include_method(:public_method)
-        object.public_method
-      end
-
-      it 'keeps private methods private' do
-        object.should_receive(:private_method)
-        expect(object.private_methods).to include_method(:private_method)
-        object.public_method
-      end
-
-      it 'keeps protected methods protected' do
-        object.should_receive(:protected_method)
-        expect(object.protected_methods).to include_method(:protected_method)
-        object.public_method
-      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,
-          a_string_including("Wrong number of arguments. Expected 0, got 1.")
-        )
-      end
-    end
-  end
-end