rspec-expectations 2.13.0 → 2.14.0.rc1

data/spec/rspec/expectations/syntax_spec.rb

@@ -6,9 +6,21 @@ module RSpec
       context "when passing a message to an expectation" do
         let(:warner) { ::Kernel }
 
+        let(:string_like_object) do
+          Struct.new(:to_str, :to_s).new(*(["Ceci n'est pas une Chaine."]*2))
+        end
+
+        let(:insufficiently_string_like_object) do
+          Struct.new(:to_s).new("Ceci n'est pas une Chaine.")
+        end
+
+        let(:callable_object) do
+          Struct.new(:call).new("Ceci n'est pas une Chaine.")
+        end
+
         describe "expect(...).to" do
           it "prints a warning when the message object isn't a String" do
-            warner.should_receive(:warn).with /ignoring.*message/
+            warner.should_receive(:warn).with(/ignoring.*message/)
             expect(3).to eq(3), :not_a_string
           end
 
@@ -16,11 +28,26 @@ module RSpec
             warner.should_not_receive(:warn)
             expect(3).to eq(3), "a string"
           end
+
+          it "doesn't print a warning when message responds to to_str" do
+            warner.should_not_receive(:warn)
+            expect(3).to eq(3), string_like_object
+          end
+
+          it "prints a warning when the message object handles to_s but not to_str" do
+            warner.should_receive(:warn).with(/ignoring.*message/)
+            expect(3).to eq(3), insufficiently_string_like_object
+          end
+
+          it "doesn't print a warning when message responds to call" do
+            warner.should_not_receive(:warn)
+            expect(3).to eq(3), callable_object
+          end
         end
 
-        describe "expect(...).to_not" do
+        describe "expect(...).not_to" do
           it "prints a warning when the message object isn't a String" do
-            warner.should_receive(:warn).with /ignoring.*message/
+            warner.should_receive(:warn).with(/ignoring.*message/)
             expect(3).not_to eq(4), :not_a_string
           end
 
@@ -28,6 +55,21 @@ module RSpec
             warner.should_not_receive(:warn)
             expect(3).not_to eq(4), "a string"
           end
+
+          it "doesn't print a warning when message responds to to_str" do
+            warner.should_not_receive(:warn)
+            expect(3).not_to eq(4), string_like_object
+          end
+
+          it "prints a warning when the message object handles to_s but not to_str" do
+            warner.should_receive(:warn).with(/ignoring.*message/)
+            expect(3).not_to eq(4), insufficiently_string_like_object
+          end
+
+          it "doesn't print a warning when message responds to call" do
+            warner.should_not_receive(:warn)
+            expect(3).not_to eq(4), callable_object
+          end
         end
       end
 

data/spec/rspec/matchers/be_close_spec.rb

@@ -4,17 +4,17 @@ module RSpec
   module Matchers
     describe "expect(actual).to be_close(expected, delta)" do
       before(:each) do
-        RSpec.stub(:warn)
+        allow(RSpec).to receive(:deprecate)
       end
 
-      it "delegates to be_within(delta).of(expected)" do
-        should_receive(:be_within).with(0.5).and_return( be_within_matcher = stub )
-        be_within_matcher.should_receive(:of).with(3.0)
+      it "is deprecated" do
+        expect(RSpec).to receive(:deprecate).with(/be_close.*/, :replacement => "be_within(0.5).of(3.0)")
         be_close(3.0, 0.5)
       end
 
-      it "prints a deprecation warning" do
-        RSpec.should_receive(:warn).with(/please use be_within.*instead/)
+      it "delegates to be_within(delta).of(expected)" do
+        should_receive(:be_within).with(0.5).and_return( be_within_matcher = double )
+        be_within_matcher.should_receive(:of).with(3.0)
         be_close(3.0, 0.5)
       end
     end

data/spec/rspec/matchers/be_spec.rb

@@ -2,24 +2,24 @@ require 'spec_helper'
 
 describe "expect(...).to be_predicate" do
   it "passes when actual returns true for :predicate?" do
-    actual = stub("actual", :happy? => true)
+    actual = double("actual", :happy? => true)
     expect(actual).to be_happy
   end
 
   it "passes when actual returns true for :predicates? (present tense)" do
-    actual = stub("actual", :exists? => true, :exist? => true)
+    actual = double("actual", :exists? => true, :exist? => true)
     expect(actual).to be_exist
   end
 
   it "fails when actual returns false for :predicate?" do
-    actual = stub("actual", :happy? => false)
+    actual = double("actual", :happy? => false)
     expect {
       expect(actual).to be_happy
     }.to fail_with("expected happy? to return true, got false")
   end
 
   it "fails when actual returns false for :predicate?" do
-    actual = stub("actual", :happy? => nil)
+    actual = double("actual", :happy? => nil)
     expect {
       expect(actual).to be_happy
     }.to fail_with("expected happy? to return true, got nil")
@@ -32,7 +32,7 @@ describe "expect(...).to be_predicate" do
   end
 
   it "fails on error other than NameError" do
-    actual = stub("actual")
+    actual = double("actual")
     actual.should_receive(:foo?).and_raise("aaaah")
     expect {
       expect(actual).to be_foo
@@ -50,17 +50,17 @@ end
 
 describe "expect(...).not_to be_predicate" do
   it "passes when actual returns false for :sym?" do
-    actual = stub("actual", :happy? => false)
+    actual = double("actual", :happy? => false)
     expect(actual).not_to be_happy
   end
 
   it "passes when actual returns nil for :sym?" do
-    actual = stub("actual", :happy? => nil)
+    actual = double("actual", :happy? => nil)
     expect(actual).not_to be_happy
   end
 
   it "fails when actual returns true for :sym?" do
-    actual = stub("actual", :happy? => true)
+    actual = double("actual", :happy? => true)
     expect {
       expect(actual).not_to be_happy
     }.to fail_with("expected happy? to return false, got true")
@@ -75,13 +75,13 @@ end
 
 describe "expect(...).to be_predicate(*args)" do
   it "passes when actual returns true for :predicate?(*args)" do
-    actual = mock("actual")
+    actual = double("actual")
     actual.should_receive(:older_than?).with(3).and_return(true)
     expect(actual).to be_older_than(3)
   end
 
   it "fails when actual returns false for :predicate?(*args)" do
-    actual = mock("actual")
+    actual = double("actual")
     actual.should_receive(:older_than?).with(3).and_return(false)
     expect {
       expect(actual).to be_older_than(3)
@@ -97,13 +97,13 @@ end
 
 describe "expect(...).not_to be_predicate(*args)" do
   it "passes when actual returns false for :predicate?(*args)" do
-    actual = mock("actual")
+    actual = double("actual")
     actual.should_receive(:older_than?).with(3).and_return(false)
     expect(actual).not_to be_older_than(3)
   end
 
   it "fails when actual returns true for :predicate?(*args)" do
-    actual = mock("actual")
+    actual = double("actual")
     actual.should_receive(:older_than?).with(3).and_return(true)
     expect {
       expect(actual).not_to be_older_than(3)
@@ -119,16 +119,16 @@ end
 
 describe "expect(...).to be_predicate(&block)" do
   it "passes when actual returns true for :predicate?(&block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_receive(:check_happy).and_return(true)
     expect(actual).to be_happy { delegate.check_happy }
   end
 
   it "fails when actual returns false for :predicate?(&block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_receive(:check_happy).and_return(false)
     expect {
@@ -137,7 +137,7 @@ describe "expect(...).to be_predicate(&block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_happy => true)
+    delegate = double("delegate", :check_happy => true)
     expect {
       expect(Object.new).to be_happy { delegate.check_happy }
     }.to raise_error(NameError)
@@ -146,16 +146,16 @@ end
 
 describe "expect(...).not_to be_predicate(&block)" do
   it "passes when actual returns false for :predicate?(&block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_receive(:check_happy).and_return(false)
     expect(actual).not_to be_happy { delegate.check_happy }
   end
 
   it "fails when actual returns true for :predicate?(&block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_receive(:check_happy).and_return(true)
     expect {
@@ -164,7 +164,7 @@ describe "expect(...).not_to be_predicate(&block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_happy => true)
+    delegate = double("delegate", :check_happy => true)
     expect {
       expect(Object.new).not_to be_happy { delegate.check_happy }
     }.to raise_error(NameError)
@@ -173,16 +173,16 @@ end
 
 describe "expect(...).to be_predicate(*args, &block)" do
   it "passes when actual returns true for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:older_than?).with(3).and_yield(3)
     delegate.should_receive(:check_older_than).with(3).and_return(true)
     expect(actual).to be_older_than(3) { |age| delegate.check_older_than(age) }
   end
 
   it "fails when actual returns false for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:older_than?).with(3).and_yield(3)
     delegate.should_receive(:check_older_than).with(3).and_return(false)
     expect {
@@ -191,7 +191,7 @@ describe "expect(...).to be_predicate(*args, &block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_older_than => true)
+    delegate = double("delegate", :check_older_than => true)
     expect {
       expect(Object.new).to be_older_than(3) { |age| delegate.check_older_than(age) }
     }.to raise_error(NameError)
@@ -200,16 +200,16 @@ end
 
 describe "expect(...).not_to be_predicate(*args, &block)" do
   it "passes when actual returns false for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:older_than?).with(3).and_yield(3)
     delegate.should_receive(:check_older_than).with(3).and_return(false)
     expect(actual).not_to be_older_than(3) { |age| delegate.check_older_than(age) }
   end
 
   it "fails when actual returns true for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:older_than?).with(3).and_yield(3)
     delegate.should_receive(:check_older_than).with(3).and_return(true)
     expect {
@@ -218,7 +218,7 @@ describe "expect(...).not_to be_predicate(*args, &block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_older_than => true)
+    delegate = double("delegate", :check_older_than => true)
     expect {
       expect(Object.new).not_to be_older_than(3) { |age| delegate.check_older_than(age) }
     }.to raise_error(NameError)
@@ -465,10 +465,10 @@ end
 
 describe "'expect(...).to be' with operator" do
   it "includes 'be' in the description" do
-    expect((be > 6).description).to match /be > 6/
-    expect((be >= 6).description).to match /be >= 6/
-    expect((be <= 6).description).to match /be <= 6/
-    expect((be < 6).description).to match /be < 6/
+    expect((be > 6).description).to match(/be > 6/)
+    expect((be >= 6).description).to match(/be >= 6/)
+    expect((be <= 6).description).to match(/be <= 6/)
+    expect((be < 6).description).to match(/be < 6/)
   end
 end
 

data/spec/rspec/matchers/be_within_spec.rb

@@ -27,6 +27,10 @@ module RSpec
         expect(5.5).to be_within(0.5).of(5.0)
       end
 
+      it "passes with integer arguments that are near each other" do
+        expect(1.0001).to be_within(5).percent_of(1)
+      end
+
       it "fails when actual < (expected - delta)" do
         expect {
           expect(4.49).to be_within(0.5).of(5.0)

data/spec/rspec/matchers/change_spec.rb

@@ -156,12 +156,12 @@ describe "expect { ... }.not_to change(actual, message)" do
   end
 
   it "passes when actual is not modified by the block" do
-    expect { }.to_not change(@instance, :some_value)
+    expect { }.not_to change(@instance, :some_value)
   end
 
   it "fails when actual is not modified by the block" do
     expect do
-      expect {@instance.some_value = 6}.to_not change(@instance, :some_value)
+      expect {@instance.some_value = 6}.not_to change(@instance, :some_value)
     end.to fail_with("some_value should not have changed, but did change from 5 to 6")
   end
 end
@@ -206,18 +206,18 @@ describe "expect { ... }.not_to change { block }" do
   end
 
   it "passes when actual is modified by the block" do
-    expect {}.to_not change{ @instance.some_value }
+    expect {}.not_to change{ @instance.some_value }
   end
 
   it "fails when actual is not modified by the block" do
     expect do
-      expect {@instance.some_value = 6}.to_not change { @instance.some_value }
+      expect {@instance.some_value = 6}.not_to change { @instance.some_value }
     end.to fail_with("result should not have changed, but did change from 5 to 6")
   end
 
   it "warns if passed a block using do/end instead of {}" do
     expect do
-      expect {}.to_not change do; end
+      expect {}.not_to change do; end
     end.to raise_error(SyntaxError, /block passed to should or should_not/)
   end
 end
@@ -537,6 +537,6 @@ describe RSpec::Matchers::BuiltIn::Change do
 
     expect {
       expect { @instance.some_value = "cat" }.to change(@instance, :some_value)
-    }.to_not raise_error
+    }.not_to raise_error
   end
 end

data/spec/rspec/matchers/configuration_spec.rb

@@ -22,7 +22,12 @@ module RSpec
         end
 
         before do
-          RSpec.configuration.stub(:backtrace_clean_patterns) { [/clean-me/] }
+          @old_patterns = RSpec.configuration.backtrace_exclusion_patterns
+          RSpec.configuration.backtrace_exclusion_patterns = [/clean-me/]
+        end
+
+        after do
+          RSpec.configuration.backtrace_exclusion_patterns = @old_patterns
         end
 
         it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
@@ -36,7 +41,7 @@ module RSpec
         end
 
         it "can be set to another backtrace formatter" do
-          config.backtrace_formatter = stub(:format_backtrace => ['a'])
+          config.backtrace_formatter = double(:format_backtrace => ['a'])
           expect(formatted_backtrace).to eq(['a'])
         end
       end
@@ -60,134 +65,97 @@ module RSpec
       end
 
       shared_examples_for "configuring the expectation syntax" do
-        # We want a sandboxed method that ensures that we wind up with
-        # both syntaxes properly enabled when the example ends.
-        #
-        # On platforms that fork, using a sub process is the easiest,
-        # most robust way to achieve that.
-        #
-        # On jRuby we just re-enable both syntaxes at the end of the example;
-        # however, this is a generally inferior approach because it depends on
-        # the code-under-test working properly; if it doesn't work properly,
-        # it could leave things in a "broken" state where tons of other examples fail.
-        if RUBY_PLATFORM == "java"
-          def sandboxed
-            orig_syntax = RSpec::Matchers.configuration.syntax
-            yield
-          ensure
-            configure_syntax(orig_syntax)
-          end
-        else
-          include InSubProcess
-          alias sandboxed in_sub_process
+        before do
+          @orig_syntax = RSpec::Matchers.configuration.syntax
+        end
+
+        after do
+          configure_syntax(@orig_syntax)
         end
 
         it 'can limit the syntax to :should' do
-          sandboxed do
-            configure_syntax :should
-            configured_syntax.should eq([:should])
+          configure_syntax :should
+          configured_syntax.should eq([:should])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            lambda { expect(6).to eq(6) }.should raise_error(NameError)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          lambda { expect(6).to eq(6) }.should raise_error(NameError)
         end
 
         it 'is a no-op when configured to :should twice' do
-          sandboxed do
-            configure_syntax :should
-
-            Expectations::Syntax.default_should_host.
-                                 stub(:method_added).
-                                 and_raise("no methods should be added here")
-
-            configure_syntax :should
-          end
+          configure_syntax :should
+          Expectations::Syntax.default_should_host.should_not_receive(:method_added)
+          configure_syntax :should
+          RSpec::Mocks.verify # because configure_syntax is called again in an after hook
         end
 
         it 'can limit the syntax to :expect' do
-          sandboxed do
-            configure_syntax :expect
-            expect(configured_syntax).to eq([:expect])
+          configure_syntax :expect
+          expect(configured_syntax).to eq([:expect])
 
-            expect(3).to eq(3)
-            expect { 3.should eq(3) }.to raise_error(NameError)
-            expect { 3.should_not eq(3) }.to raise_error(NameError)
-          end
+          expect(3).to eq(3)
+          expect { 3.should eq(3) }.to raise_error(NameError)
+          expect { 3.should_not eq(3) }.to raise_error(NameError)
         end
 
         it 'is a no-op when configured to :expect twice' do
-          sandboxed do
-            RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
+          RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
 
-            configure_syntax :expect
-            configure_syntax :expect
-          end
+          configure_syntax :expect
+          configure_syntax :expect
         end
 
         it 'can re-enable the :should syntax' do
-          sandboxed do
-            configure_syntax :expect
-            configure_syntax [:should, :expect]
-            configured_syntax.should eq([:should, :expect])
+          configure_syntax :expect
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            expect(3).to eq(3)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
         end
 
         it 'can re-enable the :expect syntax' do
-          sandboxed do
-            configure_syntax :should
-            configure_syntax [:should, :expect]
-            configured_syntax.should eq([:should, :expect])
+          configure_syntax :should
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            expect(3).to eq(3)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
         end
 
         it 'does not add the deprecated #should to ExpectationTarget when only :should is enabled' do
           et = Expectations::ExpectationTarget
 
-          sandboxed do
-            configure_syntax :should
-            et.new(Proc.new {}).should be_an(et)
-            et.new(Proc.new {}).should_not be_a(Proc)
-          end
+          configure_syntax :should
+          et.new(Proc.new {}).should be_an(et)
+          et.new(Proc.new {}).should_not be_a(Proc)
         end
 
         it 'does not add the deprecated #should to ExpectationTarget when only :expect is enabled' do
-          sandboxed do
-            configure_syntax :expect
-            expect(expect(3)).not_to respond_to(:should)
-            expect(expect(3)).not_to respond_to(:should_not)
-          end
+          configure_syntax :expect
+          expect(expect(3)).not_to respond_to(:should)
+          expect(expect(3)).not_to respond_to(:should_not)
         end
 
         context 'when both :expect and :should are enabled' do
-          before { RSpec.stub(:warn) }
+          before { allow(RSpec).to receive(:deprecate) }
 
           it 'allows `expect {}.should` to be used' do
-            sandboxed do
-              configure_syntax [:should, :expect]
-              expect { raise "boom" }.should raise_error("boom")
-              expect { }.should_not raise_error
-            end
+            configure_syntax [:should, :expect]
+            expect { raise "boom" }.should raise_error("boom")
+            expect { }.should_not raise_error
           end
 
           it 'prints a deprecation notice when `expect {}.should` is used' do
-            sandboxed do
-              configure_syntax [:should, :expect]
+            configure_syntax [:should, :expect]
 
-              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to.*instead/)
-              expect { raise "boom" }.should raise_error("boom")
+            expect(RSpec).to receive(:deprecate)
+            expect { raise "boom" }.should raise_error("boom")
 
-              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to_not.*instead/)
-              expect { }.should_not raise_error
-            end
+            expect(RSpec).to receive(:deprecate)
+            expect { }.should_not raise_error
           end
         end
       end