rspec 0.7.5.1 → 0.8.0

data/spec/spec/mocks/null_object_mock_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    context "a mock acting as a NullObject" do
+      setup do
+        @mock = Mock.new("null_object", :null_object => true)
+      end
+
+      specify "should allow explicit expectation" do
+        @mock.should_receive(:something)
+        @mock.something
+      end
+
+      specify "should fail verification when explicit exception not met" do
+        lambda do
+          @mock.should_receive(:something)
+          @mock.__verify
+        end.should_raise(MockExpectationError)
+      end
+
+      specify "should ignore unexpected methods" do
+        @mock.random_call("a", "d", "c")
+        @mock.__verify
+      end
+
+      specify "should expected message with different args first" do
+        @mock.should_receive(:message).with(:expected_arg)
+        @mock.message(:unexpected_arg)
+        @mock.message(:expected_arg)
+      end
+
+      specify "should expected message with different args second" do
+        @mock.should_receive(:message).with(:expected_arg)
+        @mock.message(:expected_arg)
+        @mock.message(:unexpected_arg)
+      end
+    end
+  end
+end

data/spec/spec/mocks/once_counts_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+module Mocks
+context "OnceCounts" do
+    setup do
+        @mock = Mock.new("test mock", {
+          :auto_verify => false
+        })
+      
+    end
+    specify "once should fail when called once with wrong args" do
+        @mock.should_receive(:random_call).once.with("a", "b", "c")
+        lambda do
+          @mock.random_call("d", "e", "f")
+        end.should_raise(MockExpectationError)
+      
+    end
+    specify "once should fail when called twice" do
+        @mock.should_receive(:random_call).once
+        @mock.random_call
+        @mock.random_call
+        lambda do
+          @mock.__verify
+        end.should_raise(MockExpectationError)
+      
+    end
+    specify "once should fail when not called" do
+        @mock.should_receive(:random_call).once
+        lambda do
+          @mock.__verify
+        end.should_raise(MockExpectationError)
+      
+    end
+    specify "once should pass when called once" do
+        @mock.should_receive(:random_call).once
+        @mock.random_call
+        @mock.__verify
+      
+    end
+    specify "once should pass when called once with specified args" do
+        @mock.should_receive(:random_call).once.with("a", "b", "c")
+        @mock.random_call("a", "b", "c")
+        @mock.__verify
+      
+    end
+    specify "once should pass when called once with unspecified args" do
+        @mock.should_receive(:random_call).once
+        @mock.random_call("a", "b", "c")
+        @mock.__verify
+      
+    end
+  
+end
+end
+end

data/spec/spec/mocks/options_hash_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    context "calling :should_receive with an options hash" do
+      specify "should report the file and line submitted with :expected_from" do
+        spec = Spec::Runner::Specification.new "spec" do
+          mock = Spec::Mocks::Mock.new("a mock")
+          mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
+        end
+        reporter = mock("reporter", :null_object => true)
+        reporter.should_receive(:spec_finished) do |spec, error|
+          error.backtrace.detect {|line| line =~ /\/path\/to\/blah.ext:37/}.should_not_be nil
+        end
+        spec.run(reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+
+      specify "should use the message supplied with :message" do
+        spec = Spec::Runner::Specification.new "spec" do
+          mock = Spec::Mocks::Mock.new("a mock")
+          mock.should_receive(:message, :message => "recebi nada")
+        end
+        reporter = mock("reporter", :null_object => true)
+        reporter.should_receive(:spec_finished) do |spec, error|
+          error.message.should == "recebi nada"
+        end
+        spec.run(reporter, nil, nil, nil, ::Spec::Runner::ExecutionContext.new(nil))
+      end
+    end
+  end
+end

data/spec/spec/mocks/partial_mock_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    context "using a Partial Mock," do
+      setup do
+        @object = Object.new
+      end
+      
+      specify "should_not_receive should mock out the method" do
+        @object.should_not_receive(:fuhbar)
+        @object.fuhbar
+        lambda do
+          @object.__verify
+        end.should_raise(Spec::Mocks::MockExpectationError)
+      end
+
+      specify "should_not_receive should return a negative message expectation" do
+        @object.should_not_receive(:foobar).should_be_kind_of(NegativeMessageExpectation)
+      end
+
+      specify "should_receive should mock out the method" do
+        @object.should_receive(:foobar).with(:test_param).and_return(1)
+        @object.foobar(:test_param).should equal(1)
+      end
+
+      specify "should_receive should handle a hash" do
+        @object.should_receive(:foobar).with(:key => "value").and_return(1)
+        @object.foobar(:key => "value").should equal(1)
+      end
+
+      specify "should_receive should handle 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
+
+      specify "should_receive should return a message expectation" do
+        @object.should_receive(:foobar).should_be_kind_of(MessageExpectation)
+        @object.foobar
+      end
+
+      specify "should_receive should verify method was called" do
+        @object.should_receive(:foobar).with(:test_param).and_return(1)
+        lambda do
+          @object.__verify
+        end.should_raise(Spec::Mocks::MockExpectationError)
+      end
+
+    end
+  end
+end

data/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+module Mocks
+context "PartialMockUsingMocksDirectly" do
+    setup do
+      
+        klass=Class.new
+        klass.class_eval do
+          def existing_method
+            :original_value
+          end
+        end
+        @obj = klass.new
+      
+    end
+    specify "should clear expectations on verify" do
+        @obj.should_receive(:msg)
+        @obj.msg
+        @obj.__verify
+        lambda do
+          @obj.msg
+        end.should_raise(NoMethodError)
+      
+    end
+    specify "should fail when expected message is not received" do
+        @obj.should_receive(:msg)
+        lambda do
+          @obj.__verify
+        end.should_raise(MockExpectationError)
+      
+    end
+    specify "should fail when message is received with incorrect args" do
+        @obj.should_receive(:msg).with(:correct_arg)
+        lambda do
+          @obj.msg(:incorrect_arg)
+        end.should_raise(MockExpectationError)
+        @obj.msg(:correct_arg)
+      
+    end
+    specify "should pass when expected message is received" do
+        @obj.should_receive(:msg)
+        @obj.msg
+        @obj.__verify
+      
+    end
+    specify "should pass when message is received with correct args" do
+        @obj.should_receive(:msg).with(:correct_arg)
+        @obj.msg(:correct_arg)
+        @obj.__verify
+      
+    end
+    specify "should revert to original method if 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.__verify
+        @obj.existing_method.should equal(:original_value)
+      
+    end
+  
+end
+end
+end

data/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    context "a mock, in handling arguments" do
+      setup do
+        @mock = Mock.new("test mock")
+      end
+      
+      teardown do
+        @mock.__verify
+      end
+
+      specify "should accept true as boolean" do
+        @mock.should_receive(:random_call).with(:boolean)
+        @mock.random_call(true)
+      end
+      
+      specify "should accept false as boolean" do
+        @mock.should_receive(:random_call).with(:boolean)
+        @mock.random_call(false)
+      end
+
+      specify "should accept fixnum as numeric" do
+        @mock.should_receive(:random_call).with(:numeric)
+        @mock.random_call(1)
+      end
+
+      specify "should accept float as numeric" do
+        @mock.should_receive(:random_call).with(:numeric)
+        @mock.random_call(1.5)
+      end
+
+      specify "should accept string as anything" do
+        @mock.should_receive(:random_call).with("a", :anything, "c")
+        @mock.random_call("a", "whatever", "c")
+      end
+
+      specify "should match duck type with one method" do
+        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:length))
+        @mock.random_call([])
+      end
+
+      specify "should match duck type with two methods" do
+        @mock.should_receive(:random_call).with(DuckTypeArgConstraint.new(:abs, :div))
+        @mock.random_call(1)
+      end
+
+      specify "should match non special symbol" do
+        @mock.should_receive(:random_call).with(:some_symbol)
+        @mock.random_call(:some_symbol)
+      end
+
+      specify "should match string" do
+        @mock.should_receive(:random_call).with(:string)
+        @mock.random_call("a string")
+      end
+
+      specify "should match string against regexp" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        @mock.random_call("abcde")
+      end
+
+      specify "should match regexp against regexp" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        @mock.random_call(/bcd/)
+      end
+      
+      specify "should match against a hash submitted and received by value" do
+        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
+        @mock.random_call(:a => "a", :b => "b")
+      end
+      
+      specify "should match against a hash submitted by reference and received by value" do
+        opts = {:a => "a", :b => "b"}
+        @mock.should_receive(:random_call).with(opts)
+        @mock.random_call(:a => "a", :b => "b")
+      end
+      
+      specify "should match against a hash submitted by value and received by reference" do
+        opts = {:a => "a", :b => "b"}
+        @mock.should_receive(:random_call).with(:a => "a", :b => "b")
+        @mock.random_call(opts)
+      end
+      
+      specify "should match against a Matcher" do
+        @mock.should_receive(:msg).with(equal(37))
+        @mock.msg(37)
+      end
+    end
+  end
+end

data/spec/spec/mocks/precise_counts_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+module Mocks
+context "PreciseCounts" do
+    setup do
+        @mock = Mock.new("test mock", {
+          :auto_verify => false
+        })
+      
+    end
+    specify "should fail when exactly n times method is called less than n times" do
+        @mock.should_receive(:random_call).exactly(3).times
+        @mock.random_call
+        @mock.random_call
+        lambda do
+          @mock.__verify
+        end.should_raise(MockExpectationError)
+      
+    end
+    specify "should fail when exactly n times method is never called" do
+        @mock.should_receive(:random_call).exactly(3).times
+        lambda do
+          @mock.__verify
+        end.should_raise(MockExpectationError)
+      
+    end
+    specify "should pass if exactly n times method is called exactly n times" do
+        @mock.should_receive(:random_call).exactly(3).times
+        @mock.random_call
+        @mock.random_call
+        @mock.random_call
+        @mock.__verify
+      
+    end
+    specify "should pass multiple calls with different args and counts" do
+        @mock.should_receive(:random_call).twice.with(1)
+        @mock.should_receive(:random_call).once.with(2)
+        @mock.random_call(1)
+        @mock.random_call(2)
+        @mock.random_call(1)
+        @mock.__verify
+      
+    end
+    specify "should pass mutiple calls with different args" do
+        @mock.should_receive(:random_call).once.with(1)
+        @mock.should_receive(:random_call).once.with(2)
+        @mock.random_call(1)
+        @mock.random_call(2)
+        @mock.__verify
+      
+    end
+  
+end
+end
+end

data/spec/spec/mocks/record_messages_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Mocks
+    context "a mock" do
+      setup do
+        @mock = mock("mock", :null_object => true)
+      end
+      specify "should answer false for received_message? when no messages received" do
+        @mock.received_message?(:message).should be(false)
+      end
+      specify "should answer true for received_message? when message received" do
+        @mock.message
+        @mock.received_message?(:message).should be(true)
+      end
+      specify "should answer 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
+      specify "should answer 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/spec/mocks/stub_spec.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Mocks
+    context "A method stub" do
+      setup do
+        @class = Class.new do
+          def self.existing_class_method
+            :original_value
+          end
+
+          def existing_instance_method
+            :original_value
+          end
+        end
+        @obj = @class.new
+      end
+
+      specify "should allow for a mock expectation to temporarily replace a method stub on a mock" do
+        mock = Spec::Mocks::Mock.new("a mock")
+        mock.stub!(:msg).and_return(:stub_value)
+        mock.should_receive(:msg).with(:arg).and_return(:mock_value)
+        mock.msg(:arg).should equal(:mock_value)
+        mock.msg.should equal(:stub_value)
+        mock.msg.should equal(:stub_value)
+        mock.__verify
+      end
+
+      specify "should allow for a mock expectation to temporarily replace a method stub on a non-mock" do
+        @obj.stub!(:msg).and_return(:stub_value)
+        @obj.should_receive(:msg).with(:arg).and_return(:mock_value)
+        @obj.msg(:arg).should equal(:mock_value)
+        @obj.msg.should equal(:stub_value)
+        @obj.msg.should equal(:stub_value)
+        @obj.__verify
+      end
+
+      specify "should ignore when expected message is not received" do
+        @obj.stub!(:msg)
+        lambda do
+          @obj.__verify
+        end.should_not_raise
+      end
+      
+      specify "should clear itself on __verify" do
+        @obj.stub!(:this_should_go).and_return(:blah)
+        @obj.this_should_go.should_equal :blah
+        @obj.__verify
+        lambda do
+          @obj.this_should_go
+        end.should_raise
+      end
+
+      specify "should ignore when expected message is received" do
+        @obj.stub!(:msg)
+        @obj.msg
+        @obj.__verify
+      end
+
+      specify "should ignore when message is received with args" do
+        @obj.stub!(:msg)
+        @obj.msg(:an_arg)
+        @obj.__verify
+      end
+
+      specify "should not support with" do
+        lambda do
+          Spec::Mocks::Mock.new("a mock").stub!(:msg).with(:arg)
+        end.should_raise(NoMethodError)
+      end
+      
+      specify "should return expected value when expected message is received" do
+        @obj.stub!(:msg).and_return(:return_value)
+        @obj.msg.should equal(:return_value)
+        @obj.__verify
+      end
+
+      specify "should return values in order to consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @obj.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @obj.msg.should_eql return_values[0]
+        @obj.msg.should_eql return_values[1]
+        @obj.msg.should_eql return_values[2]
+      end
+
+      specify "should keep returning last value in consecutive calls" do
+        return_values = ["1",2,Object.new]
+        @obj.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @obj.msg.should_eql return_values[0]
+        @obj.msg.should_eql return_values[1]
+        @obj.msg.should_eql return_values[2]
+        @obj.msg.should_eql return_values[2]
+        @obj.msg.should_eql return_values[2]
+      end
+
+      specify "should revert to original instance method if existed" do
+        @obj.existing_instance_method.should equal(:original_value)
+        @obj.stub!(:existing_instance_method).and_return(:mock_value)
+        @obj.existing_instance_method.should equal(:mock_value)
+        @obj.__verify
+        # TODO JRUBY: This causes JRuby to fail with:
+        # NativeException in 'Stub should revert to original instance method if existed'
+        # java.lang.ArrayIndexOutOfBoundsException: 0
+        # org.jruby.internal.runtime.methods.IterateCallable.internalCall(IterateCallable.java:63)
+        # org.jruby.internal.runtime.methods.AbstractCallable.call(AbstractCallable.java:64)
+        # org.jruby.runtime.ThreadContext.yieldInternal(ThreadContext.java:574)
+        # org.jruby.runtime.ThreadContext.yieldSpecificBlock(ThreadContext.java:549)
+        # org.jruby.runtime.Block.call(Block.java:158)
+        # org.jruby.RubyProc.call(RubyProc.java:118)
+        # org.jruby.internal.runtime.methods.ProcMethod.internalCall(ProcMethod.java:69)
+        # org.jruby.internal.runtime.methods.AbstractMethod.call(AbstractMethod.java:58)
+        # org.jruby.RubyObject.callMethod(RubyObject.java:379)
+        # org.jruby.RubyObject.callMethod(RubyObject.java:331)
+        # org.jruby.evaluator.EvaluationState.evalInternal(EvaluationState.java:472)
+        # org.jruby.evaluator.EvaluationState.evalInternal(EvaluationState.java:462)
+        # org.jruby.evaluator.EvaluationState.evalInternal(EvaluationState.java:390)
+        # org.jruby.evaluator.EvaluationState.eval(EvaluationState.java:133)
+        @obj.existing_instance_method.should equal(:original_value)
+      end
+      
+      specify "should revert to original class method if existed" do
+        @class.existing_class_method.should equal(:original_value)
+        @class.stub!(:existing_class_method).and_return(:mock_value)
+        @class.existing_class_method.should equal(:mock_value)
+        @class.__verify
+        @class.existing_class_method.should equal(:original_value)
+      end
+
+      specify "should clear itself on __verify" do
+        @obj.stub!(:this_should_go).and_return(:blah)
+        @obj.this_should_go.should_equal :blah
+        @obj.__verify
+        lambda do
+          @obj.this_should_go
+        end.should_raise
+      end
+      
+      specify "should support yielding" do
+        @obj.stub!(:method_that_yields).and_yield(:yielded_value)
+        current_value = :value_before
+        @obj.method_that_yields {|val| current_value = val}
+        current_value.should_equal :yielded_value
+        @obj.__verify
+      end
+
+      specify "should throw when told to" do
+        @mock.stub!(:something).and_throw(:blech)
+        lambda do
+          @mock.something
+        end.should_throw(:blech)
+      end
+      
+      specify "should support overriding w/ a new stub" do
+        @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
+        @stub.existing_instance_method.should == :updated_stub_value
+      end
+    end
+  end
+end