rspec-mocks 2.5.0 → 2.6.0.rc2

data/spec/rspec/mocks/any_number_of_times_spec.rb

@@ -1,36 +1,30 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    
-    describe "AnyNumberOfTimes" do
-      before(:each) do
-        @mock = RSpec::Mocks::Mock.new("test mock")
-      end
+describe "AnyNumberOfTimes" do
+  before(:each) do
+    @mock = RSpec::Mocks::Mock.new("test mock")
+  end
 
-      it "passes if any number of times method is called many times" do
-        @mock.should_receive(:random_call).any_number_of_times
-        (1..10).each do
-          @mock.random_call
-        end
-      end
+  it "passes if any number of times method is called many times" do
+    @mock.should_receive(:random_call).any_number_of_times
+    (1..10).each do
+      @mock.random_call
+    end
+  end
 
-      it "passes if any number of times method is called once" do
-        @mock.should_receive(:random_call).any_number_of_times
-        @mock.random_call
-      end
-      
-      it "passes if any number of times method is not called" do
-        @mock.should_receive(:random_call).any_number_of_times
-      end
+  it "passes if any number of times method is called once" do
+    @mock.should_receive(:random_call).any_number_of_times
+    @mock.random_call
+  end
 
-      it "returns the mocked value when called after a similar stub" do
-        @mock.stub(:message).and_return :stub_value
-        @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
-        @mock.message.should == :mock_value
-        @mock.message.should == :mock_value
-      end
-    end
+  it "passes if any number of times method is not called" do
+    @mock.should_receive(:random_call).any_number_of_times
+  end
 
+  it "returns the mocked value when called after a similar stub" do
+    @mock.stub(:message).and_return :stub_value
+    @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
+    @mock.message.should == :mock_value
+    @mock.message.should == :mock_value
   end
 end

data/spec/rspec/mocks/at_least_spec.rb

@@ -92,6 +92,12 @@ module RSpec
         @mock.random_call
         @mock.rspec_verify
       end
+
+      it "returns the value given by a block when the at least once method is called" do
+        @mock.should_receive(:to_s).at_least(:once) { "testing" }
+        @mock.to_s.should == "testing"
+        @mock.rspec_verify
+      end
     end
   end
 end

data/spec/rspec/mocks/at_most_spec.rb

@@ -88,6 +88,12 @@ module RSpec
         @mock.should_receive(:random_call).at_most(:twice)
         @mock.rspec_verify
       end
+
+      it "returns the value given by a block when the at most once method is called" do
+        @mock.should_receive(:to_s).at_most(:once) { "testing" }
+        @mock.to_s.should == "testing"
+        @mock.rspec_verify
+      end
     end
   end
 end

data/spec/rspec/mocks/bug_report_10263_spec.rb

@@ -1,26 +1,24 @@
-describe "Mock" do
-  before do
-    @double = double("test double")
-  end
-  
-  specify "when one example has an expectation (non-mock) inside the block passed to the mock" do
-    @double.should_receive(:msg) do |b|
-      b.should be_true #this call exposes the problem
+describe "Double" do
+  let(:test_double) { double }
+
+  specify "when one example has an expectation inside the block passed to should_receive" do
+    test_double.should_receive(:msg) do |arg|
+      arg.should be_true #this call exposes the problem
     end
     begin
-      @double.msg(false)
+      test_double.msg(false)
     rescue Exception
     end
   end
   
   specify "then the next example should behave as expected instead of saying" do
-    @double.should_receive(:foobar)
-    @double.foobar
-    @double.rspec_verify
+    test_double.should_receive(:foobar)
+    test_double.foobar
+    test_double.rspec_verify
     begin
-      @double.foobar
+      test_double.foobar
     rescue Exception => e
-      e.message.should == "Double \"test double\" received unexpected message :foobar with (no args)"
+      e.message.should == "Double received unexpected message :foobar with (no args)"
     end
   end 
 end

data/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -2,11 +2,9 @@ require 'spec_helper'
 
 module Bug7611
   describe "A Partial Mock" do
-    class Foo
-    end
+    class Foo; end
+    class Bar < Foo; end
 
-    class Bar < Foo
-    end
     it "respects subclasses" do
       Foo.stub(:new).and_return(Object.new)
     end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -4,93 +4,92 @@ module RSpec
   module Mocks
     describe "failing MockArgumentMatchers" do
       before(:each) do
-        @mock = double("test double")
-        @reporter = RSpec::Mocks::Mock.new("reporter").as_null_object
+        @double = double("double")
+        @reporter = double("reporter").as_null_object
       end
       
       after(:each) do
-        @mock.rspec_reset
+        @double.rspec_reset
       end
 
       it "rejects non boolean" do
-        @mock.should_receive(:random_call).with(boolean())
-        lambda do
-          @mock.random_call("false")
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        @double.should_receive(:random_call).with(boolean())
+        expect do
+          @double.random_call("false")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "rejects non numeric" do
-        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
-        lambda do
-          @mock.random_call("1")
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        @double.should_receive(:random_call).with(an_instance_of(Numeric))
+        expect do
+          @double.random_call("1")
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
       end
       
       it "rejects non string" do
-        @mock.should_receive(:random_call).with(an_instance_of(String))
-        lambda do
-          @mock.random_call(123)
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+        @double.should_receive(:random_call).with(an_instance_of(String))
+        expect do
+          @double.random_call(123)
+        end.to raise_error(RSpec::Mocks::MockExpectationError)
       end
       
       it "rejects goose when expecting a duck" do
-        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
-        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(RSpec::Mocks::MockExpectationError)
+        @double.should_receive(:random_call).with(duck_type(:abs, :div))
+        expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "fails if regexp does not match submitted string" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        lambda { @mock.random_call("abc") }.should raise_error(RSpec::Mocks::MockExpectationError)
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
       
       it "fails if regexp does not match submitted regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        lambda { @mock.random_call(/bcde/) }.should raise_error(RSpec::Mocks::MockExpectationError)
+        @double.should_receive(:random_call).with(/bcd/)
+        expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
       
       it "fails for a hash w/ wrong values" do
-        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
-        lambda do
-          @mock.random_call(:a => "b", :c => "e")
-        end.should raise_error(RSpec::Mocks::MockExpectationError, /Double "test double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call(:a => "b", :c => "e")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
       end
       
       it "fails for a hash w/ wrong keys" do
-        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
-        lambda do
-          @mock.random_call("a" => "b", "c" => "d")
-        end.should raise_error(RSpec::Mocks::MockExpectationError, /Double "test double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+        @double.should_receive(:random_call).with(:a => "b", :c => "d")
+        expect do
+          @double.random_call("a" => "b", "c" => "d")
+        end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
       end
       
       it "matches against a Matcher" do
-        lambda do
-          @mock.should_receive(:msg).with(equal(3))
-          @mock.msg(37)
-        end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
+        expect do
+          @double.should_receive(:msg).with(equal(3))
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
       end
       
       it "fails no_args with one arg" do
-        lambda do
-          @mock.should_receive(:msg).with(no_args)
-          @mock.msg(37)
-        end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
+        expect do
+          @double.should_receive(:msg).with(no_args)
+          @double.msg(37)
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
       end
       
       it "fails hash_including with missing key" do
-         lambda do
-           @mock.should_receive(:msg).with(hash_including(:a => 1))
-           @mock.msg({})
-         end.should raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+         expect do
+           @double.should_receive(:msg).with(hash_including(:a => 1))
+           @double.msg({})
+         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
       end
 
       it "fails with block matchers" do
-        lambda do
-          @mock.should_receive(:msg).with {|arg| arg.should == :received }
-          @mock.msg :no_msg_for_you
-        end.should raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+        expect do
+          @double.should_receive(:msg).with {|arg| arg.should == :received }
+          @double.msg :no_msg_for_you
+        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end
             
     end
   end
 end
-

data/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -13,9 +13,8 @@ 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 `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.%
+        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)

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -1,144 +1,141 @@
 require 'spec_helper'
 
-def include_mock_argument_matchers
-  before(:each) do
-    @mock = RSpec::Mocks::Mock.new("test mock")
-    Kernel.stub(:warn)
-  end
-  
-  after(:each) do
-    @mock.rspec_verify
-  end
-end
 module RSpec
   module Mocks
-    
-    describe Methods, "handling argument matchers" do
-      include_mock_argument_matchers
-
-      it "accepts true as boolean()" do
-        @mock.should_receive(:random_call).with(boolean())
-        @mock.random_call(true)
+    describe Methods do
+      before(:each) do
+        @double = double('double')
+        Kernel.stub(:warn)
       end
 
-      it "accepts false as boolean()" do
-        @mock.should_receive(:random_call).with(boolean())
-        @mock.random_call(false)
+      after(:each) do
+        @double.rspec_verify
       end
 
-      it "accepts fixnum as kind_of(Numeric)" do
-        @mock.should_receive(:random_call).with(kind_of(Numeric))
-        @mock.random_call(1)
-      end
+      context "handling argument matchers" do
+        it "accepts true as boolean()" do
+          @double.should_receive(:random_call).with(boolean())
+          @double.random_call(true)
+        end
 
-      it "accepts 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 "accepts false as boolean()" do
+          @double.should_receive(:random_call).with(boolean())
+          @double.random_call(false)
+        end
 
-      it "does NOT accept fixnum as instance_of(Numeric)" do
-        @mock.should_not_receive(:random_call).with(instance_of(Numeric))
-        @mock.random_call(1)
-      end
+        it "accepts fixnum as kind_of(Numeric)" do
+          @double.should_receive(:random_call).with(kind_of(Numeric))
+          @double.random_call(1)
+        end
 
-      it "does 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 "accepts float as an_instance_of(Numeric)" do
+          @double.should_receive(:random_call).with(kind_of(Numeric))
+          @double.random_call(1.5)
+        end
 
-      it "accepts string as anything()" do
-        @mock.should_receive(:random_call).with("a", anything(), "c")
-        @mock.random_call("a", "whatever", "c")
-      end
+        it "accepts fixnum as instance_of(Fixnum)" do
+          @double.should_receive(:random_call).with(instance_of(Fixnum))
+          @double.random_call(1)
+        end
 
-      it "matches duck type with one method" do
-        @mock.should_receive(:random_call).with(duck_type(:length))
-        @mock.random_call([])
-      end
+        it "does NOT accept fixnum as instance_of(Numeric)" do
+          @double.should_not_receive(:random_call).with(instance_of(Numeric))
+          @double.random_call(1)
+        end
 
-      it "matches duck type with two methods" do
-        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
-        @mock.random_call(1)
-      end
-      
-      it "matches no args against any_args()" do
-        @mock.should_receive(:random_call).with(any_args)
-        @mock.random_call()
-      end
-      
-      it "matches one arg against any_args()" do
-        @mock.should_receive(:random_call).with(any_args)
-        @mock.random_call("a string")
-      end
-      
-      it "matches no args against no_args()" do
-        @mock.should_receive(:random_call).with(no_args)
-        @mock.random_call()
-      end
-      
-      it "matches hash with hash_including same hash" do
-        @mock.should_receive(:random_call).with(hash_including(:a => 1))
-        @mock.random_call(:a => 1)
-      end
-        
-    end
+        it "does NOT accept float as instance_of(Numeric)" do
+          @double.should_not_receive(:random_call).with(instance_of(Numeric))
+          @double.random_call(1.5)
+        end
 
-    describe Methods, "handling block matchers" do
-      include_mock_argument_matchers
-      
-      it "matches 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 = RSpec::Mocks::Mock.new("test mock")
-      end
-      
-      it "matches 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 "accepts string as anything()" do
+          @double.should_receive(:random_call).with("a", anything(), "c")
+          @double.random_call("a", "whatever", "c")
+        end
 
-      it "matches string against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call("abcde")
-      end
+        it "matches duck type with one method" do
+          @double.should_receive(:random_call).with(duck_type(:length))
+          @double.random_call([])
+        end
 
-      it "matches regexp against regexp" do
-        @mock.should_receive(:random_call).with(/bcd/)
-        @mock.random_call(/bcd/)
-      end
-      
-      it "matches 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")
+        it "matches duck type with two methods" do
+          @double.should_receive(:random_call).with(duck_type(:abs, :div))
+          @double.random_call(1)
+        end
+
+        it "matches no args against any_args()" do
+          @double.should_receive(:random_call).with(any_args)
+          @double.random_call()
+        end
+
+        it "matches one arg against any_args()" do
+          @double.should_receive(:random_call).with(any_args)
+          @double.random_call("a string")
+        end
+
+        it "matches no args against no_args()" do
+          @double.should_receive(:random_call).with(no_args)
+          @double.random_call()
+        end
+
+        it "matches hash with hash_including same hash" do
+          @double.should_receive(:random_call).with(hash_including(:a => 1))
+          @double.random_call(:a => 1)
+        end
       end
-      
-      it "matches 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")
+
+      context "handling block matchers" do
+        it "matches arguments against RSpec expectations" do
+          @double.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]
+          }
+          @double.random_call 5, "hello", [1,2,3], :fee, "fi", 4
+        end
+
+        it "does not eval the block as the return value" do
+          eval_count = 0
+          @double.should_receive(:msg).with {|a| eval_count += 1}
+          @double.msg(:ignore)
+          eval_count.should eq(1)
+        end
       end
-      
-      it "matches 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)
+
+      context "handling non-matcher arguments" do
+        it "matches non special symbol (can be removed when deprecated symbols are removed)" do
+          @double.should_receive(:random_call).with(:some_symbol)
+          @double.random_call(:some_symbol)
+        end
+
+        it "matches string against regexp" do
+          @double.should_receive(:random_call).with(/bcd/)
+          @double.random_call("abcde")
+        end
+
+        it "matches regexp against regexp" do
+          @double.should_receive(:random_call).with(/bcd/)
+          @double.random_call(/bcd/)
+        end
+
+        it "matches against a hash submitted and received by value" do
+          @double.should_receive(:random_call).with(:a => "a", :b => "b")
+          @double.random_call(:a => "a", :b => "b")
+        end
+
+        it "matches against a hash submitted by reference and received by value" do
+          opts = {:a => "a", :b => "b"}
+          @double.should_receive(:random_call).with(opts)
+          @double.random_call(:a => "a", :b => "b")
+        end
+
+        it "matches against a hash submitted by value and received by reference" do
+          opts = {:a => "a", :b => "b"}
+          @double.should_receive(:random_call).with(:a => "a", :b => "b")
+          @double.random_call(opts)
+        end
       end
     end
   end