rspec-mocks 2.13.1 → 2.14.0.rc1

data/spec/rspec/mocks/at_least_spec.rb

@@ -8,8 +8,8 @@ module RSpec
       it "fails if method is never called" do
         @double.should_receive(:do_something).at_least(4).times
         expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+          verify @double
+        }.to raise_error(/expected: at least 4 times.*received: 0 times/m)
       end
 
       it "fails when called less than n times" do
@@ -18,30 +18,30 @@ module RSpec
         @double.do_something
         @double.do_something
         expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+          verify @double
+        }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
       end
 
       it "fails when at least once method is never called" do
         @double.should_receive(:do_something).at_least(:once)
         expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+          verify @double
+        }.to raise_error(/expected: at least 1 time.*received: 0 times/m)
       end
 
       it "fails when at least twice method is called once" do
         @double.should_receive(:do_something).at_least(:twice)
         @double.do_something
         expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+          verify @double
+        }.to raise_error(/expected: at least 2 times.*received: 1 time/m)
       end
 
       it "fails when at least twice method is never called" do
         @double.should_receive(:do_something).at_least(:twice)
         expect {
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+          verify @double
+        }.to raise_error(/expected: at least 2 times.*received: 0 times/m)
       end
 
       it "passes when at least n times method is called exactly n times" do
@@ -50,7 +50,7 @@ module RSpec
         @double.do_something
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at least n times method is called n plus 1 times" do
@@ -60,20 +60,20 @@ module RSpec
         @double.do_something
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at least once method is called once" do
         @double.should_receive(:do_something).at_least(:once)
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at least once method is called twice" do
         @double.should_receive(:do_something).at_least(:once)
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at least twice method is called three times" do
@@ -81,47 +81,56 @@ module RSpec
         @double.do_something
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at least twice method is called twice" do
         @double.should_receive(:do_something).at_least(:twice)
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "returns the value given by a block when the at least once method is called" do
         @double.should_receive(:to_s).at_least(:once) { "testing" }
         expect(@double.to_s).to eq "testing"
-        @double.rspec_verify
+        verify @double
       end
 
-      it "passes with at_least(0) with no return if called once" do
-        @double.should_receive(:do_something).at_least(0).times
-        @double.do_something
-      end
+      context "when sent with 0" do
+        before { RSpec.stub(:deprecate) }
 
-      it "passes with at_least(0) with return block if called once" do
-        @double.should_receive(:do_something).at_least(0).times { true }
-        @double.do_something
-      end
+        it "outputs a deprecation warning" do
+          expect(RSpec).to receive(:deprecate).with("at_least\(0\) with should_receive", :replacement => "stub")
+          expect(@double).to receive(:do_something).at_least(0).times
+        end
 
-      it "passes with at_least(0) with and_return if called once" do
-        @double.should_receive(:do_something).at_least(0).times.and_return true
-        @double.do_something
-      end
+        it "passes with no return if called once" do
+          @double.should_receive(:do_something).at_least(0).times
+          @double.do_something
+        end
 
-      it "passes with at_least(0) with no return if never called" do
-        @double.should_receive(:do_something).at_least(0).times
-      end
+        it "passes with return block if called once" do
+          @double.should_receive(:do_something).at_least(0).times { true }
+          @double.do_something
+        end
 
-      it "passes with at_least(0) with return block if never called" do
-        @double.should_receive(:do_something).at_least(0).times { true }
-      end
+        it "passes with and_return if called once" do
+          @double.should_receive(:do_something).at_least(0).times.and_return true
+          @double.do_something
+        end
+
+        it "passes with no return if never called" do
+          @double.should_receive(:do_something).at_least(0).times
+        end
+
+        it "passes with return block if never called" do
+          @double.should_receive(:do_something).at_least(0).times { true }
+        end
 
-      it "passes with at_least(0) with and_return if never called" do
-        @double.should_receive(:do_something).at_least(0).times.and_return true
+        it "passes with and_return if never called" do
+          @double.should_receive(:do_something).at_least(0).times.and_return true
+        end
       end
 
       it "uses a stub value if no value set" do

data/spec/rspec/mocks/at_most_spec.rb

@@ -11,53 +11,53 @@ module RSpec
         @double.should_receive(:do_something).at_most(2).times
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(n) is called less than n times" do
         @double.should_receive(:do_something).at_most(2).times
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(n) is never called" do
         @double.should_receive(:do_something).at_most(2).times
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(:once) is called once" do
         @double.should_receive(:do_something).at_most(:once)
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(:once) is never called" do
         @double.should_receive(:do_something).at_most(:once)
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(:twice) is called once" do
         @double.should_receive(:do_something).at_most(:twice)
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(:twice) is called twice" do
         @double.should_receive(:do_something).at_most(:twice)
         @double.do_something
         @double.do_something
-        @double.rspec_verify
+        verify @double
       end
 
       it "passes when at_most(:twice) is never called" do
         @double.should_receive(:do_something).at_most(:twice)
-        @double.rspec_verify
+        verify @double
       end
 
       it "returns the value given by a block when at_most(:once) method is called" do
         @double.should_receive(:to_s).at_most(:once) { "testing" }
         expect(@double.to_s).to eq "testing"
-        @double.rspec_verify
+        verify @double
       end
 
       it "fails fast when at_most(n) times method is called n plus 1 times" do
@@ -66,7 +66,7 @@ module RSpec
         @double.do_something
         expect {
           @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
       end
 
       it "fails fast when at_most(:once) and is called twice" do
@@ -74,7 +74,7 @@ module RSpec
         @double.do_something
         expect {
           @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(/expected: at most 1 time.*received: 2 times/m)
       end
 
       it "fails fast when at_most(:twice) and is called three times" do
@@ -83,7 +83,7 @@ module RSpec
         @double.do_something
         expect {
           @double.do_something
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
       end
     end
   end

data/spec/rspec/mocks/block_return_value_spec.rb

@@ -33,7 +33,7 @@ describe "a double declaration with a block handed to:" do
     end
   end
 
-  %w[once twice any_number_of_times ordered and_return].each do |method|
+  %w[once twice ordered and_return].each do |method|
     describe method do
       it "returns the value of executing the block" do
         obj = Object.new
@@ -43,6 +43,23 @@ describe "a double declaration with a block handed to:" do
     end
   end
 
+  describe 'any_number_of_times' do
+    before do
+      RSpec.stub(:deprecate)
+    end
+
+    it "warns about deprecation" do
+      expect(RSpec).to receive(:deprecate).with("any_number_of_times", :replacement => "stub")
+      Object.new.stub(:foo).any_number_of_times { 'bar' }
+    end
+
+    it "returns the value of executing the block" do
+      obj = Object.new
+      obj.stub(:foo).any_number_of_times { 'bar' }
+      expect(obj.foo).to eq('bar')
+    end
+  end
+
   describe "times" do
     it "returns the value of executing the block" do
       obj = Object.new

data/spec/rspec/mocks/bug_report_10260_spec.rb

@@ -3,6 +3,6 @@ require 'spec_helper'
 describe "An RSpec Mock" do
   it "hides internals in its inspect representation" do
     m = double('cup')
-    expect(m.inspect).to match /#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
+    expect(m.inspect).to match(/#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/)
   end
 end

data/spec/rspec/mocks/bug_report_10263_spec.rb

@@ -16,7 +16,7 @@ describe "Double" do
   specify "then the next example should behave as expected instead of saying" do
     test_double.should_receive(:foobar)
     test_double.foobar
-    test_double.rspec_verify
+    verify test_double
     begin
       test_double.foobar
     rescue Exception => e

data/spec/rspec/mocks/bug_report_11545_spec.rb

@@ -4,17 +4,17 @@ class LiarLiarPantsOnFire
   def respond_to?(message, incl_private=false)
     true
   end
-  
+
   def self.respond_to?(message, incl_private=false)
     true
   end
 end
-  
+
 describe 'should_receive' do
   before(:each) do
     @liar = LiarLiarPantsOnFire.new
   end
-  
+
   it "works when object lies about responding to a method" do
     @liar.should_receive(:something)
     @liar.something
@@ -24,7 +24,7 @@ describe 'should_receive' do
     LiarLiarPantsOnFire.should_receive(:something)
     LiarLiarPantsOnFire.something
   end
-  
+
   it 'cleans up after itself' do
     expect((class << LiarLiarPantsOnFire; self; end).instance_methods).not_to include("something")
   end

data/spec/rspec/mocks/bug_report_600_spec.rb

@@ -9,7 +9,7 @@ module BugReport600
         end
       end
     end
- 
+
     it "works" do
       ExampleClass.should_receive(:define_method).with("defined_method")
       ExampleClass.method_that_uses_define_method

data/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -11,6 +11,6 @@ module Bug7611
 
     it "should" do
       expect(Bar.new.class).to eq Bar
-    end 
+    end
   end
 end

data/spec/rspec/mocks/configuration_spec.rb

@@ -20,6 +20,130 @@ module RSpec
         expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
         expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
       end
+
+      shared_examples_for "configuring the syntax" do
+        def sandboxed
+          orig_syntax = RSpec::Mocks.configuration.syntax
+          yield
+        ensure
+          configure_syntax(orig_syntax)
+        end
+
+        around(:each) { |ex| sandboxed(&ex) }
+        let(:dbl) { double }
+        let(:should_methods)       { [:should_receive, :stub, :should_not_receive] }
+        let(:should_class_methods) { [:any_instance] }
+        let(:expect_methods)      { [:receive, :allow, :expect_any_instance_of, :allow_any_instance_of] }
+
+        it 'defaults to enabling both the :should and :expect syntaxes' do
+          expect(dbl).to respond_to(*should_methods)
+          expect(self).to respond_to(*expect_methods)
+        end
+
+        context 'when configured to :expect' do
+          before { configure_syntax :expect }
+
+          it 'removes the should methods from every object' do
+            expect(dbl).not_to respond_to(*should_methods)
+          end
+
+          it 'removes `any_instance` from every class' do
+            expect(Class.new).not_to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :expect' do
+            expect(configured_syntax).to eq([:expect])
+          end
+
+          it 'is a no-op when configured a second time' do
+            expect(Syntax.default_should_syntax_host).not_to receive(:method_undefined)
+            expect(::RSpec::Mocks::ExampleMethods).not_to receive(:method_added)
+            configure_syntax :expect
+          end
+        end
+
+        context 'when configured to :should' do
+          before { configure_syntax :should }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'removes the expect methods from the example group context' do
+            expect(self).not_to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :should' do
+            expect(configured_syntax).to eq([:should])
+          end
+
+          it 'is a no-op when configured a second time' do
+            Syntax.default_should_syntax_host.should_not_receive(:method_added)
+            ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
+            configure_syntax :should
+          end
+        end
+
+        context 'when configured to [:should, :expect]' do
+          before { configure_syntax [:should, :expect] }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that both syntaxes are enabled' do
+            expect(configured_syntax).to eq([:should, :expect])
+          end
+        end
+      end
+
+      describe "configuring rspec-mocks directly" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec::Mocks.configuration.syntax = syntax
+          end
+
+          def configured_syntax
+            RSpec::Mocks.configuration.syntax
+          end
+        end
+      end
+
+      describe "configuring using the rspec-core config API" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                c.syntax = syntax
+              end
+            end
+          end
+
+          def configured_syntax
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                return c.syntax
+              end
+            end
+          end
+        end
+      end
     end
   end
 end