rspec 1.0.0 → 1.3.1

data/spec/spec/mocks/stub_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -13,112 +13,85 @@ module Spec
             :original_value
           end
         end
-        @obj = @class.new
+        @instance = @class.new
+        @stub = Object.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
+      [:stub!, :stub].each do |method|
+        context "using #{method}" do
+          it "should return expected value when expected message is received" do
+            @instance.send(method, :msg).and_return(:return_value)
+            @instance.msg.should equal(:return_value)
+            @instance.rspec_verify
+          end
+        end
       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
+
+      it "should ignore when message is received with args" do
+        @instance.stub!(:msg)
+        @instance.msg(:an_arg)
         lambda do
-          @obj.this_should_go
-        end.should raise_error
+          @instance.rspec_verify
+        end.should_not raise_error
       end
 
-      it "should ignore when expected message is received" do
-        @obj.stub!(:msg)
-        @obj.msg
-        @obj.rspec_verify
+      it "should ignore when expected message is not received" do
+        @instance.stub!(:msg)
+        lambda do
+          @instance.rspec_verify
+        end.should_not raise_error
       end
 
-      it "should ignore when message is received with args" do
-        @obj.stub!(:msg)
-        @obj.msg(:an_arg)
-        @obj.rspec_verify
+      it "should handle multiple stubbed methods" do
+        @instance.stub!(:msg1 => 1, :msg2 => 2)
+        @instance.msg1.should == 1
+        @instance.msg2.should == 2
       end
 
-      it "should not support with" do
+      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
-          Spec::Mocks::Mock.new("a mock").stub!(:msg).with(:arg)
-        end.should raise_error(NoMethodError)
-      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
+          @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)
-      end
-      
-      it "should revert to original class method if existed" do
+        @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 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 +99,105 @@ 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
-      end
-      
-      it "should support yielding" do
-        @obj.stub!(:method_that_yields).and_yield(:yielded_value)
+      it "should yield a specified object" do
+        @instance.stub!(:method_that_yields).and_yield(:yielded_obj)
         current_value = :value_before
-        @obj.method_that_yields {|val| current_value = val}
-        current_value.should == :yielded_value
-        @obj.rspec_verify
+        @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 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
+
+      it "calculates return value by executing block passed to #and_return" do
+        @mock.stub!(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        @mock.something("a","b","c").should == "cba"
+        @mock.rspec_verify
+      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
+
+      it "should use 'Stub' in the failure message" do
+        stub = stub('name')
+        expect {stub.foo}.to raise_error(/Stub "name" received/)
+      end
+    end
+
   end
-end
+end

data/spec/spec/mocks/stubbed_message_expectations_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "Example with stubbed and then called message" do
+      it "fails if the message is expected and then subsequently not called again" do
+        mock_obj = mock("mock", :msg => nil)
+        mock_obj.msg
+        mock_obj.should_receive(:msg)
+        lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError)
+      end
+
+      it "outputs arguments of all similar calls" do
+        m = mock('mock', :foo => true)
+        m.should_receive(:foo).with('first')
+        m.foo('second')
+        m.foo('third')
+        lambda do
+          m.rspec_verify
+        end.should raise_error(%Q|Mock "mock" received :foo with unexpected arguments\n  expected: ("first")\n       got: (["second"], ["third"])|)
+        m.rspec_reset
+      end
+    end
+    
+  end
+end

data/spec/spec/mocks/twice_counts_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -64,4 +64,4 @@ module Spec
       end
     end
   end
-end
+end

data/spec/spec/mocks/unstub_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe Mock do
+      context "unstubbing a mock object with a stub" do
+        it "should remove the stub" do
+          a_mock = mock 'an object', :foo => :bar
+
+          a_mock.unstub! :foo
+          a_mock.should_not respond_to(:foo)
+        end
+      end
+
+      context "unstubbing a real object with a stub" do
+        before do
+          @obj = Object.new
+        end
+
+        it "should raise a NoMethodError if the message is called after unstubbing" do
+          @obj.stub!(:foo).and_return :bar
+          @obj.unstub!(:foo)
+
+          lambda {
+            @obj.foo
+          }.should raise_error(NoMethodError)
+        end
+
+        it "should only clear the stub specified" do
+          @obj.stub!(:foo).and_return :bar
+          @obj.stub!(:other).and_return :baz
+
+          @obj.unstub!(:foo)
+
+          @obj.other.should == :baz
+        end
+
+        it "should no longer respond_to? the method" do
+          @obj.stub!(:foo).and_return :bar
+          @obj.unstub!(:foo)
+
+          @obj.should_not respond_to(:foo)
+        end
+
+        it "should unstub using a string (should convert the string to a symbol)" do
+          @obj.stub!(:foo)
+
+          @obj.unstub!("foo")
+
+          @obj.should_not respond_to(:foo)
+        end
+
+        it "should restore a previous method definition" do
+          def @obj.foo
+            :a_result
+          end
+
+          @obj.stub!(:foo).and_return :stubbed_result
+          @obj.unstub!(:foo)
+
+          @obj.foo.should == :a_result
+        end
+
+        it "should have unstub as an alias of unstub!" do
+          @obj.stub!(:foo).and_return :bar
+
+          @obj.unstub(:foo)
+
+          lambda {
+            @obj.foo
+          }.should raise_error(NoMethodError)
+        end
+
+        it "should raise a MockExpectationError if it is not stubbed" do
+          lambda {
+            @obj.unstub!(:foo)
+          }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed")
+        end
+
+        it "should raise a MockExpectationError if it was already unstubbed" do
+          @obj.stub!(:foo)
+          @obj.unstub!(:foo)
+
+          lambda {
+            @obj.unstub!(:foo)
+          }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed")
+        end
+
+        it "should use the correct message name in the error" do
+          @obj.stub!(:bar)
+          @obj.unstub!(:bar)
+
+          lambda {
+            @obj.unstub!(:bar)
+          }.should raise_error(MockExpectationError, "The method `bar` was not stubbed or was already unstubbed")
+        end
+
+        it "should raise a MockExpectationError if the method is defined, but not stubbed" do
+          def @obj.meth; end
+
+          lambda {
+            @obj.unstub!(:meth)
+          }.should raise_error(MockExpectationError)
+        end
+
+        it "should be able to restub a after unstubbing" do
+          @obj.stub!(:foo).and_return :bar
+
+          @obj.unstub!(:foo)
+
+          @obj.stub!(:foo).and_return :baz
+
+          @obj.foo.should == :baz
+        end
+
+        it "should remove only the first stub if multiple stubs have been defined" do
+          @obj.stub!(:foo).and_return :first
+          @obj.stub!(:foo).and_return :second
+
+          @obj.unstub!(:foo)
+
+          @obj.foo.should == :first
+        end
+      end
+    end
+  end
+end

data/spec/spec/package/bin_spec_spec.rb

@@ -1,12 +1,16 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
+require 'spec_helper'
+require 'ruby_forker'
 
 describe "The bin/spec script" do
+  include RubyForker
+  
   it "should have no warnings" do
-    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 -Ilib bin/spec --help"
     output.should_not =~ /warning/n
   end
-end
+  
+  it "should show the help w/ no args" do
+    output = ruby "-w -Ilib bin/spec"
+    output.should =~ /^Usage: spec/
+  end
+end

data/spec/spec/rake/spectask_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'spec/rake/spectask'
+
+module Spec
+  module Rake
+
+    class MockTask
+      class << self
+        attr_accessor :last_instance, :last_cmd
+      end
+
+      def self.tasks
+        @tasks ||= {}
+      end
+      
+      def self.reset_tasks
+        @tasks = {}
+      end
+      
+      def self.task(name)
+        tasks[name]
+      end
+      
+      def self.register_task(name, block)
+        tasks[name] = block
+      end
+
+      def initialize(name, &block)
+        MockTask.register_task(name, block)
+        MockTask.last_instance = block
+      end
+      
+      def self.create_task(name, &block)
+        new(name, &block)
+      end
+    end
+
+    class SpecTask
+      def task(name, &block)
+        MockTask.create_task(name, &block)
+      end
+
+      def system(cmd)
+        MockTask.last_cmd = cmd
+        true
+      end
+
+      def default_ruby_path
+        RUBY
+      end
+    end
+    
+    describe SpecTask do
+
+      before(:each) do
+        MockTask.reset_tasks
+      end
+
+      it "should execute rake's ruby path by default" do
+        task = SpecTask.new
+        MockTask.last_instance.call
+        MockTask.last_cmd.should match(/^#{task.default_ruby_path} /)
+      end
+
+      it "should execute the command with system if ruby_cmd is specified" do
+        task = SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"}
+        task.should_receive(:system).and_return(true)
+        MockTask.last_instance.call
+      end
+
+      it "should execute the ruby_cmd path if specified" do
+        SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"}
+        MockTask.last_instance.call
+        MockTask.last_cmd.should match(/^path_to_multiruby /)
+      end
+      
+      it "should produce a deprecation warning if the out option is used" do
+        SpecTask.new {|t| t.out = "somewhere_over_the_rainbow"}
+        STDERR.should_receive(:puts).with("The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead.")
+        MockTask.last_instance.call
+      end
+      
+      it "should produce an error if failure_message is set and the command fails" do
+        task = SpecTask.new {|t| t.failure_message = "oops"; t.fail_on_error = false}
+        STDERR.should_receive(:puts).with("oops")
+        task.stub(:system).and_return(false)
+        MockTask.last_instance.call
+      end
+      
+      it "should raise if fail_on_error is set and the command fails" do
+        task = SpecTask.new
+        task.stub(:system).and_return(false)
+        lambda {MockTask.last_instance.call}.should raise_error
+      end
+      
+      it "should not raise if fail_on_error is not set and the command fails" do
+        task = SpecTask.new {|t| t.fail_on_error = false}
+        task.stub(:system).and_return(false)
+        lambda {MockTask.last_instance.call}.should_not raise_error
+      end
+      
+      context "with ENV['SPEC'] set" do
+        before(:each) do
+          @orig_env_spec = ENV['SPEC']
+          ENV['SPEC'] = 'foo.rb'
+        end
+        after(:each) do
+          ENV['SPEC'] = @orig_env_spec
+        end
+        it "should use the provided file list" do
+          task = SpecTask.new
+          task.spec_file_list.should == ["foo.rb"]
+        end
+      end
+      
+      context "with the rcov option" do
+        
+        it "should create a clobber_rcov task" do
+          MockTask.stub!(:create_task)
+          MockTask.should_receive(:create_task).with(:clobber_rcov)
+          SpecTask.new(:rcov) {|t| t.rcov = true}
+        end
+
+        it "should setup the clobber_rcov task to remove the rcov directory" do
+          task = SpecTask.new(:rcov) {|t| t.rcov = true; t.rcov_dir = "path_to_rcov_directory"}
+          task.should_receive(:rm_r).with("path_to_rcov_directory")
+          MockTask.task(:clobber_rcov).call
+        end
+
+        it "should make the clobber task depend on clobber_rcov" do
+          MockTask.stub!(:create_task)
+          MockTask.should_receive(:create_task).with(:clobber => [:clobber_rcov])
+          SpecTask.new(:rcov) {|t| t.rcov = true}
+        end
+
+        it "should make the rcov task depend on clobber_rcov" do
+          MockTask.stub!(:create_task)
+          MockTask.should_receive(:create_task).with(:rcov => :clobber_rcov)
+          SpecTask.new(:rcov) {|t| t.rcov = true}
+        end
+        
+        it "creates an rcov options list" do
+          MockTask.stub!(:create_task)
+          task = SpecTask.new(:rcov) {|t| t.rcov = true, t.rcov_opts = ['a','b']}
+          task.rcov_option_list.should == "a b"
+        end
+      end
+    end
+  end
+end

data/spec/spec/runner/class_and_argument_parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Spec
+  module Runner
+    describe ClassAndArgumentsParser, ".parse" do
+      
+      it "should use a single : to separate class names from arguments" do
+        ClassAndArgumentsParser.parse('Foo').should == ['Foo', nil]
+        ClassAndArgumentsParser.parse('Foo:arg').should == ['Foo', 'arg']
+        ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg').should == ['Foo::Bar::Zap', 'arg']
+        ClassAndArgumentsParser.parse('Foo:arg1,arg2').should == ['Foo', 'arg1,arg2']
+        ClassAndArgumentsParser.parse('Foo::Bar::Zap:arg1,arg2').should == ['Foo::Bar::Zap', 'arg1,arg2']
+        ClassAndArgumentsParser.parse('Foo::Bar::Zap:drb://foo,drb://bar').should == ['Foo::Bar::Zap', 'drb://foo,drb://bar']
+      end
+
+      it "should raise an error when passed an empty string" do
+        lambda do
+          ClassAndArgumentsParser.parse('')
+        end.should raise_error("Couldn't parse \"\"")
+      end      
+    end
+  end
+end