rspec 1.0.0 → 1.3.1

data/spec/spec/mocks/multiple_return_value_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -20,7 +20,7 @@ module Spec
         third = Object.new
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it twice")
       end
 
       it "should complain when there are too many calls" do
@@ -29,7 +29,7 @@ module Spec
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
         @mock.message.should == @return_values[2]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times")
       end
     end
 
@@ -51,7 +51,7 @@ module Spec
         third = Object.new
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it twice")
       end
 
       it "should complain when there are too many calls" do
@@ -60,14 +60,14 @@ module Spec
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
         @mock.message.should == @return_values[2]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times")
       end
     end
 
     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
@@ -79,7 +79,7 @@ module Spec
 
       it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (no args) twice, but received it once")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (no args) twice, but received it once")
       end
     end
     describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
@@ -97,7 +97,7 @@ module Spec
 
       it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it once")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it once")
       end
 
       it "should fail when called greater than the specified number" do
@@ -105,7 +105,7 @@ module Spec
         @mock.message.should equal(22)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
+        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock \"mock\" expected :message with (any args) 3 times, but received it 4 times")
       end
     end
   end

data/spec/spec/mocks/nil_expectation_warning_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+
+    describe "an expectation set on nil" do
+      
+      it "should issue 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 `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.%
+        Kernel.should_receive(:warn).with(expected_warning)
+
+        nil.should_receive(:foo)
+        nil.foo
+      end
+      
+      it "should issue a warning when the expectation is negative" do
+        Kernel.should_receive(:warn)
+
+        nil.should_not_receive(:foo)
+      end
+      
+      it "should 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 "should not effect subsequent examples" do
+        example_group = Class.new(::Spec::Example::ExampleGroupDouble)
+        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.run(Spec::Runner.options).should be_true
+                  
+      end
+
+    end
+    
+  end
+end

data/spec/spec/mocks/null_object_mock_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -36,5 +36,19 @@ module Spec
         @mock.message(:unexpected_arg)
       end
     end
+
+    describe "#null_object?" do
+      it "should default to false" do
+        obj = mock('anything')
+        obj.should_not be_null_object
+      end
+    end
+    
+    describe "#as_null_object" do
+      it "should set the object to null_object" do
+        obj = mock('anything').as_null_object
+        obj.should be_null_object
+      end
+    end
   end
 end

data/spec/spec/mocks/once_counts_spec.rb

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

data/spec/spec/mocks/options_hash_spec.rb

@@ -1,32 +1,34 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
     describe "calling :should_receive with an options hash" do
       it "should report the file and line submitted with :expected_from" do
-        spec = Spec::DSL::Example.new "spec" do
+        begin
           mock = Spec::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
-        reporter = mock("reporter", :null_object => true)
-        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)
       end
 
       it "should use the message supplied with :message" do
-        spec = Spec::DSL::Example.new "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|
-          error.message.should == "recebi nada"
-        end
-        spec.run(reporter, nil, nil, nil, Object.new)
+        lambda {
+          m = Spec::Mocks::Mock.new("a mock")
+          m.should_receive(:message, :message => "recebi nada")
+          m.rspec_verify
+        }.should raise_error("recebi nada")
+      end
+      
+      it "should use the message supplied with :message after a similar stub" do
+        lambda {
+          m = Spec::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

data/spec/spec/mocks/partial_mock_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -6,47 +6,159 @@ 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:.*> expected/)
+      end
+    
+      it "should name 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(Spec::Mocks::MockExpectationError, /<Object \(class\)>/)
+      end
+    
+      it "should 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 should mock out the method" do
         @object.should_not_receive(:fuhbar)
-        @object.fuhbar
         lambda do
-          @object.rspec_verify
-        end.should raise_error(Spec::Mocks::MockExpectationError)
+          @object.fuhbar
+        end.should raise_error(MockExpectationError, /<Object:.*> expected :fuhbar with \(no args\) 0 times/)
       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
+      end
+      
+      it "should_not_receive should also take a String argument" do
+        @object.should_not_receive('foobar')
+        lambda do
+          @object.foobar   
+        end.should raise_error(Spec::Mocks::MockExpectationError)
+      end
+      
+      it "should use report nil in the error message" do
+        allow_message_expectations_on_nil
+        
+        @this_will_resolve_to_nil.should_receive(:foobar)
+        lambda do
+          @this_will_resolve_to_nil.rspec_verify
+        end.should raise_error(Spec::Mocks::MockExpectationError, /nil 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
+
+    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 'should keep public methods public' do
+        @object.should_receive(:public_method)
+        with_ruby('1.9') do
+          @object.public_methods.should include(:public_method)
+        end
+        with_ruby('1.8') do
+          @object.public_methods.should include('public_method')
+        end
+        @object.public_method
+      end
+
+      it 'should keep private methods private' do
+        @object.should_receive(:private_method)
+        with_ruby('1.9') do
+          @object.private_methods.should include(:private_method)
+        end
+        with_ruby('1.8') do
+          @object.private_methods.should include('private_method')
+        end
+        @object.public_method
+      end
+
+      it 'should keep protected methods protected' do
+        @object.should_receive(:protected_method)
+        with_ruby('1.9') do
+          @object.protected_methods.should include(:protected_method)
+        end
+        with_ruby('1.8') do
+          @object.protected_methods.should include('protected_method')
+        end
+        @object.public_method
+      end
 
     end
   end
-end
+end

data/spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 
 module Spec
 module Mocks
@@ -63,4 +63,4 @@ describe "PartialMockUsingMocksDirectly" do
   
 end
 end
-end
+end

data/spec/spec/mocks/passing_argument_matchers_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "mock argument matchers", :shared => true do
+      before(:each) do
+        @mock = Mock.new("test mock")
+        Kernel.stub!(:warn)
+      end
+      
+      after(:each) do
+        @mock.rspec_verify
+      end
+    end
+    
+    describe Methods, "handling argument matchers" do
+      it_should_behave_like "mock argument matchers"
+
+      it "should accept true as boolean()" do
+        @mock.should_receive(:random_call).with(boolean())
+        @mock.random_call(true)
+      end
+
+      it "should accept false as boolean()" do
+        @mock.should_receive(:random_call).with(boolean())
+        @mock.random_call(false)
+      end
+
+      it "should accept fixnum as kind_of(Numeric)" do
+        @mock.should_receive(:random_call).with(kind_of(Numeric))
+        @mock.random_call(1)
+      end
+
+      it "should accept float as an_instance_of(Numeric)" do
+        @mock.should_receive(:random_call).with(kind_of(Numeric))
+        @mock.random_call(1.5)
+      end
+      
+      it "accepts fixnum as instance_of(Fixnum)" do
+        @mock.should_receive(:random_call).with(instance_of(Fixnum))
+        @mock.random_call(1)
+      end
+
+      it "should NOT accept fixnum as instance_of(Numeric)" do
+        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
+        @mock.random_call(1)
+      end
+
+      it "should NOT accept float as instance_of(Numeric)" do
+        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
+        @mock.random_call(1.5)
+      end
+
+      it "should accept string as anything()" do
+        @mock.should_receive(:random_call).with("a", anything(), "c")
+        @mock.random_call("a", "whatever", "c")
+      end
+
+      it "should match duck type with one method" do
+        @mock.should_receive(:random_call).with(duck_type(:length))
+        @mock.random_call([])
+      end
+
+      it "should match duck type with two methods" do
+        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
+        @mock.random_call(1)
+      end
+      
+      it "should match no args against any_args()" do
+        @mock.should_receive(:random_call).with(any_args)
+        @mock.random_call()
+      end
+      
+      it "should match one arg against any_args()" do
+        @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
+      
+      it "should match hash with hash_including same hash" do
+        @mock.should_receive(:random_call).with(hash_including(:a => 1))
+        @mock.random_call(:a => 1)
+      end
+        
+    end
+
+    describe Methods, "handling block matchers" do
+      it_should_behave_like "mock argument matchers"
+      
+      it "should match arguments against RSpec expectations" do
+        @mock.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
+          arg1.should == 5
+          arg2.should have_at_least(3).characters
+          arg2.should have_at_most(10).characters
+          arr.map {|i| i * 2}.should == [2,4,6]
+          rest.should == [:fee, "fi", 4]
+        }
+        @mock.random_call 5, "hello", [1,2,3], :fee, "fi", 4
+      end
+    end
+    
+    describe Methods, "handling non-matcher arguments" do
+      
+      before(:each) do
+        @mock = Mock.new("test mock")
+      end
+      
+      it "should match non special symbol (can be removed when deprecated symbols are removed)" do
+        @mock.should_receive(:random_call).with(:some_symbol)
+        @mock.random_call(:some_symbol)
+      end
+
+      it "should match string against regexp" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        @mock.random_call("abcde")
+      end
+
+      it "should match regexp against regexp" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        @mock.random_call(/bcd/)
+      end
+      
+      it "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
+      
+      it "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
+      
+      it "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
+    end
+  end
+end

data/spec/spec/mocks/precise_counts_spec.rb

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

data/spec/spec/mocks/record_messages_spec.rb

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

data/spec/spec/mocks/stub_chain_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "A chained method stub" do
+      before(:each) do
+        @subject = Object.new
+      end
+
+      it "returns expected value from chaining only one method call" do
+        @subject.stub_chain(:msg1).and_return(:return_value)
+        @subject.msg1.should equal(:return_value)
+      end
+
+      it "returns expected value from chaining two method calls" do
+        @subject.stub_chain(:msg1, :msg2).and_return(:return_value)
+        @subject.msg1.msg2.should equal(:return_value)
+      end
+
+      it "returns expected value from chaining four method calls" do
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value)
+        @subject.msg1.msg2.msg3.msg4.should equal(:return_value)
+      end
+
+      it "returns expected value from two chains with shared messages at the end" do
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        @subject.stub_chain(:msg5, :msg2, :msg3, :msg4).and_return(:second)
+
+        @subject.msg1.msg2.msg3.msg4.should equal(:first)
+        @subject.msg5.msg2.msg3.msg4.should equal(:second)
+      end
+
+      it "returns expected value from two chains with shared messages at the beginning" do
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first)
+        @subject.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second)
+
+        @subject.msg1.msg2.msg3.msg4.should equal(:first)
+        @subject.msg1.msg2.msg3.msg5.should equal(:second)
+      end
+    end
+  end
+end

data/spec/spec/mocks/stub_implementation_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "stub implementation" do
+      context "with no args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) { :bar }
+          obj.foo.should == :bar
+        end
+      end
+
+      context "with one arg" do
+        it "execs the block with that arg when called" do
+          obj = stub()
+          obj.stub(:foo) {|given| given}
+          obj.foo(:bar).should == :bar
+        end
+      end
+
+      context "with variable args" do
+        it "execs the block when called" do
+          obj = stub()
+          obj.stub(:foo) {|*given| given.first}
+          obj.foo(:bar).should == :bar
+        end
+      end
+    end
+  end
+end