rspec 1.0.8 → 1.1.0

data/spec/spec/mocks/multiple_return_value_spec.rb

@@ -67,7 +67,7 @@ module Spec
     describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
       before(:each) do
         @mock = Mock.new("mock")
-        @mock.should_receive(:message).at_least(:twice).with(:no_args).and_return(11, 22)
+        @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
       end
       
       it "should use last return value for subsequent calls" do

data/spec/spec/mocks/options_hash_spec.rb

@@ -3,30 +3,42 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 module Spec
   module Mocks
     describe "calling :should_receive with an options hash" do
+      it_should_behave_like "sandboxed rspec_options"
+      attr_reader :reporter, :example_group
+      before do
+        @reporter = ::Spec::Runner::Reporter.new(options)
+        @example_group = Class.new(::Spec::Example::ExampleGroup) do
+          plugin_mock_framework
+          describe("Some Examples")
+        end
+        reporter.add_example_group example_group
+      end
+
       it "should report the file and line submitted with :expected_from" do
-        spec = Spec::DSL::Example.new "spec" do
+        example_definition = example_group.it "spec" do
           mock = Spec::Mocks::Mock.new("a mock")
           mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
           mock.rspec_verify
         end
-        reporter = mock("reporter", :null_object => true)
+        example = example_group.new(example_definition)
+        
         reporter.should_receive(:example_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, Object.new)
+        example.execute(options, {})
       end
 
       it "should use the message supplied with :message" do
-        spec = Spec::DSL::Example.new "spec" do
+        example_definition = @example_group.it "spec" do
           mock = Spec::Mocks::Mock.new("a mock")
           mock.should_receive(:message, :message => "recebi nada")
           mock.rspec_verify
         end
-        reporter = mock("reporter", :null_object => true)
-        reporter.should_receive(:example_finished) do |spec, error|
+        example = @example_group.new(example_definition)
+        @reporter.should_receive(:example_finished) do |spec, error|
           error.message.should == "recebi nada"
         end
-        spec.run(reporter, nil, nil, nil, Object.new)
+        example.execute(@options, {})
       end
     end
   end

data/spec/spec/mocks/partial_mock_spec.rb

@@ -6,14 +6,14 @@ module Spec
       before(:each) do
         @object = Object.new
       end
-
+    
       it "should name the class in the failure message" do
         @object.should_receive(:foo)
         lambda do
           @object.rspec_verify
         end.should raise_error(Spec::Mocks::MockExpectationError, /Object/)
       end
-
+    
       it "should not conflict with @options in the object" do
         @object.instance_eval { @options = Object.new }
         @object.should_receive(:blah)
@@ -27,39 +27,39 @@ module Spec
           @object.rspec_verify
         end.should raise_error(Spec::Mocks::MockExpectationError)
       end
-
+    
       it "should_not_receive should return a negative message expectation" do
         @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation)
       end
-
+    
       it "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
-
+    
       it "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
-
+    
       it "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
-
+    
       it "should_receive should return a message expectation" do
         @object.should_receive(:foobar).should be_kind_of(MessageExpectation)
         @object.foobar
       end
-
+    
       it "should_receive should verify method was called" do
         @object.should_receive(:foobar).with(:test_param).and_return(1)
         lambda do
           @object.rspec_verify
         end.should raise_error(Spec::Mocks::MockExpectationError)
       end
-
+    
       it "should_receive should also take a String argument" do
         @object.should_receive('foobar')
         @object.foobar
@@ -80,5 +80,27 @@ module Spec
         end.should raise_error(Spec::Mocks::MockExpectationError, /NilClass.*expected :foobar with/)
       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 "should not raise an error when stubbing the object" do
+        o = PartiallyMockedEquals.new :foo
+        lambda { o.stub!(:bar) }.should_not raise_error(NoMethodError)
+      end
+    end
   end
 end

data/spec/spec/mocks/passing_mock_argument_constraints_spec.rb

@@ -5,6 +5,7 @@ module Spec
     describe "mock argument constraints", :shared => true do
       before(:each) do
         @mock = Mock.new("test mock")
+        Kernel.stub!(:warn)
       end
       
       after(:each) do
@@ -49,6 +50,11 @@ module Spec
         @mock.should_receive(:random_call).with(:any_args)
         @mock.random_call("a string")
       end
+      
+      it "should match no args against no_args" do
+        @mock.should_receive(:random_call).with(:no_args)
+        @mock.random_call
+      end
     end
 
     describe Methods, "handling argument constraints" do

data/spec/spec/mocks/stub_spec.rb

@@ -13,112 +13,74 @@ module Spec
             :original_value
           end
         end
-        @obj = @class.new
+        @instance = @class.new
       end
 
-      it "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.rspec_verify
-      end
-
-      it "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.rspec_verify
+      it "should return expected value when expected message is received" do
+        @instance.stub!(:msg).and_return(:return_value)
+        @instance.msg.should equal(:return_value)
+        @instance.rspec_verify
       end
 
-      it "should ignore when expected message is not received" do
-        @obj.stub!(:msg)
+      it "should ignore when expected message is received" do
+        @instance.stub!(:msg)
+        @instance.msg
         lambda do
-          @obj.rspec_verify
+          @instance.rspec_verify
         end.should_not raise_error
       end
-      
-      it "should clear itself on rspec_verify" do
-        @obj.stub!(:this_should_go).and_return(:blah)
-        @obj.this_should_go.should == :blah
-        @obj.rspec_verify
-        lambda do
-          @obj.this_should_go
-        end.should raise_error
-      end
-
-      it "should ignore when expected message is received" do
-        @obj.stub!(:msg)
-        @obj.msg
-        @obj.rspec_verify
-      end
 
       it "should ignore when message is received with args" do
-        @obj.stub!(:msg)
-        @obj.msg(:an_arg)
-        @obj.rspec_verify
+        @instance.stub!(:msg)
+        @instance.msg(:an_arg)
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
       end
 
-      it "should not support with" do
+      it "should ignore when expected message is not received" do
+        @instance.stub!(:msg)
         lambda do
-          Spec::Mocks::Mock.new("a mock").stub!(:msg).with(:arg)
-        end.should raise_error(NoMethodError)
+          @instance.rspec_verify
+        end.should_not raise_error
       end
       
-      it "should return expected value when expected message is received" do
-        @obj.stub!(:msg).and_return(:return_value)
-        @obj.msg.should equal(:return_value)
-        @obj.rspec_verify
+      it "should clear itself when verified" do
+        @instance.stub!(:this_should_go).and_return(:blah)
+        @instance.this_should_go.should == :blah
+        @instance.rspec_verify
+        lambda do
+          @instance.this_should_go
+        end.should raise_error(NameError)
       end
 
       it "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 == return_values[0]
-        @obj.msg.should == return_values[1]
-        @obj.msg.should == return_values[2]
+        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @instance.msg.should == return_values[0]
+        @instance.msg.should == return_values[1]
+        @instance.msg.should == return_values[2]
       end
 
       it "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 == return_values[0]
-        @obj.msg.should == return_values[1]
-        @obj.msg.should == return_values[2]
-        @obj.msg.should == return_values[2]
-        @obj.msg.should == return_values[2]
-      end
-
-      it "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.rspec_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)
+        @instance.stub!(:msg).and_return(return_values[0],return_values[1],return_values[2])
+        @instance.msg.should == return_values[0]
+        @instance.msg.should == return_values[1]
+        @instance.msg.should == return_values[2]
+        @instance.msg.should == return_values[2]
+        @instance.msg.should == return_values[2]
+      end
+
+      it "should revert to original instance method if there is one" do
+        @instance.existing_instance_method.should equal(:original_value)
+        @instance.stub!(:existing_instance_method).and_return(:mock_value)
+        @instance.existing_instance_method.should equal(:mock_value)
+        @instance.rspec_verify
+        @instance.existing_instance_method.should equal(:original_value)
       end
       
-      it "should revert to original class method if existed" do
+      it "should revert to original class method if there is one" 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)
@@ -126,34 +88,94 @@ module Spec
         @class.existing_class_method.should equal(:original_value)
       end
 
-      it "should clear itself on rspec_verify" do
-        @obj.stub!(:this_should_go).and_return(:blah)
-        @obj.this_should_go.should == :blah
-        @obj.rspec_verify
-        lambda do
-          @obj.this_should_go
-        end.should raise_error
+      it "should yield a specified object" do
+        @instance.stub!(:method_that_yields).and_yield(:yielded_obj)
+        current_value = :value_before
+        @instance.method_that_yields {|val| current_value = val}
+        current_value.should == :yielded_obj
+        @instance.rspec_verify
+      end
+
+      it "should yield multiple times with multiple calls to and_yield" do
+        @instance.stub!(:method_that_yields_multiple_times).and_yield(:yielded_value).
+                                                       and_yield(:another_value)
+        current_value = []
+        @instance.method_that_yields_multiple_times {|val| current_value << val}
+        current_value.should == [:yielded_value, :another_value]
+        @instance.rspec_verify
       end
       
-      it "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 == :yielded_value
-        @obj.rspec_verify
+      it "should yield a specified object and return another specified object" do
+        yielded_obj = mock("my mock")
+        yielded_obj.should_receive(:foo).with(:bar)
+        @instance.stub!(:method_that_yields_and_returns).and_yield(yielded_obj).and_return(:baz)
+        @instance.method_that_yields_and_returns { |o| o.foo :bar }.should == :baz
       end
 
       it "should throw when told to" do
-        @mock.stub!(:something).and_throw(:blech)
+        @mock.stub!(:something).and_throw(:up)
         lambda do
           @mock.something
-        end.should throw_symbol(:blech)
+        end.should throw_symbol(:up)
       end
       
-      it "should support overriding w/ a new stub" do
+      it "should override a pre-existing stub" do
         @stub.stub!(:existing_instance_method).and_return(:updated_stub_value)
         @stub.existing_instance_method.should == :updated_stub_value
       end
+      
+      it "should limit " do
+        @stub.stub!(:foo).with("bar")
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+    end
+    
+    describe "A method stub with args" do
+      before(:each) do
+        @stub = Object.new
+        @stub.stub!(:foo).with("bar")
+      end
+
+      it "should not complain if not called" do
+      end
+
+      it "should not complain if called with arg" do
+        @stub.foo("bar")
+      end
+
+      it "should complain if called with no arg" do
+        lambda do
+          @stub.foo
+        end.should raise_error
+      end
+
+      it "should complain if called with other arg" do
+        lambda do
+          @stub.foo("other")
+        end.should raise_error
+      end
+
+      it "should not complain if also mocked w/ different args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+      end
+
+      it "should complain if also mocked w/ different args AND called w/ a 3rd set of args" do
+        @stub.should_receive(:foo).with("baz")
+        @stub.foo("bar")
+        @stub.foo("baz")
+        lambda do
+          @stub.foo("other")
+        end.should raise_error
+      end
+      
+      it "should support options" do
+        @stub.stub!(:foo, :expected_from => "bar")
+      end
     end
+
   end
 end

data/spec/spec/package/bin_spec_spec.rb

@@ -1,12 +1,14 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../ruby_forker'
 
 describe "The bin/spec script" do
+  include RubyForker
+  
   it "should have no warnings" do
+    pending "Hangs on JRuby" if PLATFORM =~ /java/
     spec_path = "#{File.dirname(__FILE__)}/../../../bin/spec"
-    output = nil
-    IO.popen("ruby -w #{spec_path} --help 2>&1") do |io|
-      output = io.read
-    end
+
+    output = ruby "-w #{spec_path} --help 2>&1"
     output.should_not =~ /warning/n
   end
 end