rspec-mocks 2.11.3 → 3.11.1

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "a message expectation with multiple return values and no specified count" do
-      before(:each) do
-        @double = double
-        @return_values = [1,2,3]
-        @double.should_receive(:do_something).and_return(@return_values[0],@return_values[1],@return_values[2])
-      end
-
-      it "returns values in order" do
-        @double.do_something.should eq @return_values[0]
-        @double.do_something.should eq @return_values[1]
-        @double.do_something.should eq @return_values[2]
-        @double.rspec_verify
-      end
-
-      it "falls back to a previously stubbed value" do
-        @double.stub :do_something => :stub_result
-        @double.do_something.should eq @return_values[0]
-        @double.do_something.should eq @return_values[1]
-        @double.do_something.should eq @return_values[2]
-        @double.do_something.should eq :stub_result
-      end
-
-      it "fails when there are too few calls (if there is no stub)" do
-        @double.do_something
-        @double.do_something
-        expect { @double.rspec_verify }.to raise_error
-      end
-
-      it "fails when there are too many calls (if there is no stub)" do
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect { @double.rspec_verify }.to raise_error
-      end
-    end
-
-    describe "a message expectation with multiple return values with a specified count equal to the number of values" do
-      before(:each) do
-        @double = double
-        @return_values = [1,2,3]
-        @double.should_receive(:do_something).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
-      end
-
-      it "returns values in order to consecutive calls" do
-        @double.do_something.should eq @return_values[0]
-        @double.do_something.should eq @return_values[1]
-        @double.do_something.should eq @return_values[2]
-        @double.rspec_verify
-      end
-    end
-
-    describe "a message expectation with multiple return values specifying at_least less than the number of values" do
-      before(:each) do
-        @double = double
-        @double.should_receive(:do_something).at_least(:twice).with(no_args).and_return(11, 22)
-      end
-
-      it "uses the last return value for subsequent calls" do
-        @double.do_something.should equal(11)
-        @double.do_something.should equal(22)
-        @double.do_something.should equal(22)
-        @double.rspec_verify
-      end
-
-      it "fails when called less than the specified number" do
-        @double.do_something.should equal(11)
-        expect { @double.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      context "when method is stubbed too" do
-        before { @double.stub(:do_something).and_return :stub_result }
-
-        it "uses the last value for subsequent calls" do
-          @double.do_something.should equal(11)
-          @double.do_something.should equal(22)
-          @double.do_something.should equal(22)
-          @double.rspec_verify
-        end
-
-        it "fails when called less than the specified number" do
-          @double.do_something.should equal(11)
-          expect { @double.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-      end
-    end
-
-    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::Mock.new("double")
-        @double.should_receive(:do_something).exactly(3).times.and_return(11, 22)
-      end
-
-      it "uses the last return value for subsequent calls" do
-        @double.do_something.should equal(11)
-        @double.do_something.should equal(22)
-        @double.do_something.should equal(22)
-        @double.rspec_verify
-      end
-
-      it "fails when called less than the specified number" do
-        @double.do_something
-        @double.do_something
-        expect { @double.rspec_verify }.to raise_error
-      end
-
-      it "fails fast when called greater than the specified number" do
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect { @double.do_something }.to raise_error
-      end
-    end
-  end
-end

data/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-def remove_last_describe_from_world
-  RSpec::world.example_groups.pop
-end
-
-def empty_example_group
-  RSpec::Core::ExampleGroup.describe(Object, 'Empty Behaviour Group') { }
-  remove_last_describe_from_world
-end
-
-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
-
-    end
-    
-    describe "#allow_message_expectations_on_nil" do
-      
-
-      it "does not effect subsequent examples" do
-        example_group = empty_example_group
-        example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
-                        allow_message_expectations_on_nil
-                      end
-        example_group.it("should not effect the next exapmle ran") do
-                        Kernel.should_receive(:warn)
-                        nil.should_receive(:foo)
-                        nil.foo
-                      end
-                              
-        example_group
-                  
-      end
-
-    end
-    
-  end
-end

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -1,106 +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
-        @double.should_not respond_to(:foo)
-      end
-
-      it "says it responds to messages it does understand" do
-        @double.stub(:foo)
-        @double.should respond_to(:foo)
-      end
-
-      it "raises an error when interpolated in a string as an integer" do
-        # Not sure why, but 1.9.2 raises a different error than 1.8.7 and 1.9.3...
-        expected_error = RUBY_VERSION == '1.9.2' ?
-                         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
-        @double.should respond_to(:any_message_it_gets)
-      end
-
-      it "allows explicit stubs" do
-        @double.stub(:foo) { "bar" }
-        @double.foo.should 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)
-        @double.foo.bar.should be(@double)
-      end
-
-      it 'returns an explicitly stubbed value from an expectation with no implementation' do
-        @double.stub(:foo => "bar")
-        @double.should_receive(:foo)
-        @double.foo.should eq("bar")
-      end
-
-      it "fails verification when explicit exception not met" do
-        lambda do
-          @double.should_receive(:something)
-          @double.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "ignores unexpected methods" do
-        @double.random_call("a", "d", "c")
-        @double.rspec_verify
-      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.
-        ("%i" % @double).should eq("0")
-      end
-    end
-    
-    describe "#as_null_object" do
-      it "sets the object to null_object" do
-        obj = double('anything').as_null_object
-        obj.should be_null_object
-      end
-    end
-
-    describe "#null_object?" do
-      it "defaults to false" do
-        obj = double('anything')
-        obj.should_not be_null_object
-      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
-        @double.rspec_verify
-      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")
-        @double.rspec_verify
-      end
-
-      it "passes when called once with unspecified args" do
-        @double.should_receive(:do_something).once
-        @double.do_something("a", "b", "c")
-        @double.rspec_verify
-      end
-
-      it "fails when called with wrong args" do
-        @double.should_receive(:do_something).once.with("a", "b", "c")
-        lambda do
-          @double.do_something("d", "e", "f")
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
-        @double.rspec_reset
-      end
-
-      it "fails fast when called twice" do
-        @double.should_receive(:do_something).once
-        @double.do_something
-        lambda do
-          @double.do_something
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
-      end
-      
-      it "fails when not called" do
-        @double.should_receive(:do_something).once
-        lambda do
-          @double.rspec_verify
-        end.should 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::Mock.new("a mock")
-          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
-          mock.rspec_verify
-        rescue Exception => e
-        ensure
-          e.backtrace.to_s.should =~ /\/path\/to\/blah.ext:37/m
-        end
-      end
-
-      it "uses the message supplied with :message" do
-        lambda {
-          m = RSpec::Mocks::Mock.new("a mock")
-          m.should_receive(:message, :message => "recebi nada")
-          m.rspec_verify
-        }.should raise_error("recebi nada")
-      end
-      
-      it "uses the message supplied with :message after a similar stub" do
-        lambda {
-          m = RSpec::Mocks::Mock.new("a mock")
-          m.stub(:message)
-          m.should_receive(:message, :message => "from mock")
-          m.rspec_verify
-        }.should raise_error("from mock")
-      end
-    end
-  end
-end

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "using a Partial Mock," do
-      before(:each) do
-        @object = Object.new
-      end
-    
-      it "names the class in the failure message" do
-        @object.should_receive(:foo)
-        expect do
-          @object.rspec_verify
-        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)
-        lambda do
-          Object.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
-      end
-    
-      it "does not conflict with @options in the object" do
-        @object.instance_eval { @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\n    received\: 1 time/
-        )
-      end
-    
-      it "should_not_receive returns a negative message expectation" do
-        @object.should_not_receive(:foobar).should be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
-      end
-    
-      it "should_receive mocks out the method" do
-        @object.should_receive(:foobar).with(:test_param).and_return(1)
-        @object.foobar(:test_param).should equal(1)
-      end
-    
-      it "should_receive handles a hash" do
-        @object.should_receive(:foobar).with(:key => "value").and_return(1)
-        @object.foobar(:key => "value").should 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)
-        @object.foobar(hash[:a]).should equal(1)
-      end
-    
-      it "should_receive returns a message expectation" do
-        @object.should_receive(:foobar).should be_kind_of(RSpec::Mocks::MessageExpectation)
-        @object.foobar
-      end
-    
-      it "should_receive verifies method was called" do
-        @object.should_receive(:foobar).with(:test_param).and_return(1)
-        lambda do
-          @object.rspec_verify
-        end.should 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')
-        lambda do
-          @object.foobar   
-        end.should 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 {
-          @nil.rspec_verify
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError, 
-          %Q|(nil).foobar(any args)\n    expected: 1 time\n    received: 0 times|
-        )
-      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.to_s
-            "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 "Partially mocking an object that defines ==, after another mock has been defined" do
-      before(:each) do
-        stub("existing mock", :foo => :foo)
-      end
-      
-      class PartiallyMockedEquals
-        attr_reader :val
-        def initialize(val)
-          @val = val
-        end
-        
-        def ==(other)
-          @val == other.val
-        end
-      end
-      
-      it "does not raise an error when stubbing the object" do
-        o = PartiallyMockedEquals.new :foo
-        lambda { o.stub(:bar) }.should_not raise_error(NoMethodError)
-      end
-    end
-
-    describe "Method visibility when using partial mocks" do
-      class MockableClass
-        def public_method
-          private_method
-          protected_method
-        end
-        protected
-        def protected_method; end
-        private
-        def private_method; end
-      end
-
-      before(:each) do
-        @object = MockableClass.new
-      end
-
-      it 'keeps public methods public' do
-        @object.should_receive(:public_method)
-        @object.public_methods.should include_method(:public_method)
-        @object.public_method
-      end
-
-      it 'keeps private methods private' do
-        @object.should_receive(:private_method)
-        @object.private_methods.should include_method(:private_method)
-        @object.public_method
-      end
-
-      it 'keeps protected methods protected' do
-        @object.should_receive(:protected_method)
-        @object.protected_methods.should include_method(:protected_method)
-        @object.public_method
-      end
-
-    end
-  end
-end

data/spec/rspec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Mocks
-  describe "PartialMockUsingMocksDirectly" 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
-    #     obj.rspec_verify
-    #     lambda do
-    #       obj.msg
-    #     end.should raise_error(NoMethodError)
-    #   
-    # end
-    it "fails when expected message is not received" do
-      obj.should_receive(:msg)
-      lambda do
-        obj.rspec_verify
-      end.should raise_error(RSpec::Mocks::MockExpectationError)
-    end
-
-    it "fails when message is received with incorrect args" do
-      obj.should_receive(:msg).with(:correct_arg)
-      lambda do
-        obj.msg(:incorrect_arg)
-      end.should raise_error(RSpec::Mocks::MockExpectationError)
-      obj.msg(:correct_arg)
-    end
-
-    it "passes when expected message is received" do
-      obj.should_receive(:msg)
-      obj.msg
-      obj.rspec_verify
-    end
-
-    it "passes when message is received with correct args" do
-      obj.should_receive(:msg).with(:correct_arg)
-      obj.msg(:correct_arg)
-      obj.rspec_verify
-    end
-
-    it "restores the original method if it existed" do
-      obj.existing_method.should equal(:original_value)
-      obj.should_receive(:existing_method).and_return(:mock_value)
-      obj.existing_method.should equal(:mock_value)
-      obj.rspec_verify
-      obj.existing_method.should equal(:original_value)
-    end
-
-    context "with an instance method handled by method_missing" do
-      it "restores the original behavior" do
-        obj.captured_by_method_missing.should eq("response generated by method missing")
-        obj.stub(:captured_by_method_missing) { "foo" }
-        obj.captured_by_method_missing.should eq("foo")
-        obj.rspec_reset
-        obj.captured_by_method_missing.should eq("response generated by method missing")
-      end
-    end
-
-    context "with a class method handled by method_missing" do 
-      it "restores the original behavior" do
-        klass.captured_by_method_missing.should eq("response generated by method missing")
-        klass.stub(:captured_by_method_missing) { "foo" }
-        klass.captured_by_method_missing.should eq("foo")
-        klass.rspec_reset
-        klass.captured_by_method_missing.should eq("response generated by method missing")
-      end
-    end
-  end
-end