rspec-expectations 2.13.0 → 2.14.0

data/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Object, "#should" do
   before(:each) do
     @target = "target"
-    @matcher = mock("matcher")
-    @matcher.stub!(:matches?).and_return(true)
-    @matcher.stub!(:failure_message_for_should)
+    @matcher = double("matcher")
+    @matcher.stub(:matches?).and_return(true)
+    @matcher.stub(:failure_message_for_should)
   end
 
   it "accepts and interacts with a matcher" do
@@ -47,12 +47,12 @@ end
 describe Object, "#should_not" do
   before(:each) do
     @target = "target"
-    @matcher = mock("matcher")
+    @matcher = double("matcher")
   end
 
   it "accepts and interacts with a matcher" do
     @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @matcher.stub!(:failure_message_for_should_not)
+    @matcher.stub(:failure_message_for_should_not)
 
     expect(@target).not_to @matcher
   end

data/spec/rspec/expectations/fail_with_spec.rb

@@ -1,6 +1,25 @@
 # encoding: utf-8
 require 'spec_helper'
 
+
+describe RSpec::Expectations, "#fail_with with diff of arrays" do
+  before { RSpec::Matchers.configuration.stub(:color? => false) }
+
+  it "splits items with newlines" do
+    expected_diff = "\nDiff:\n@@ -1 +1,3 @@\n+a\\nb\n+c\\nd\n"
+    expect {
+      RSpec::Expectations.fail_with("", [], ["a\nb", "c\nd"])
+    }.to fail_with(expected_diff)
+  end
+
+  it "shows inner arrays on a single line" do
+    expected_diff = "\nDiff:\n@@ -1 +1,3 @@\n+a\\nb\n+[\"c\\nd\"]\n"
+    expect {
+      RSpec::Expectations.fail_with("", [], ["a\nb", ["c\nd"]])
+    }.to fail_with(expected_diff)
+  end
+end
+
 describe RSpec::Expectations, "#fail_with with diff" do
   let(:differ) { double("differ") }
 

data/spec/rspec/expectations/handler_spec.rb

@@ -49,21 +49,21 @@ module RSpec
     describe PositiveExpectationHandler do
       describe "#handle_matcher" do
         it "asks the matcher if it matches" do
-          matcher = mock("matcher")
+          matcher = double("matcher")
           actual = Object.new
           matcher.should_receive(:matches?).with(actual).and_return(true)
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "returns the match value" do
-          matcher = mock("matcher")
+          matcher = double("matcher")
           actual = Object.new
           matcher.should_receive(:matches?).with(actual).and_return(:this_value)
           expect(RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)).to eq :this_value
         end
 
         it "calls failure_message_for_should if the matcher implements it" do
-          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          matcher = double("matcher", :failure_message_for_should => "message", :matches? => false)
           actual = Object.new
 
           ::RSpec::Expectations.should_receive(:fail_with).with("message")
@@ -72,7 +72,7 @@ module RSpec
         end
 
         it "calls fail if matcher.diffable?" do
-          matcher = mock("matcher",
+          matcher = double("matcher",
             :diffable? => true,
             :failure_message_for_should => "message",
             :matches? => false,
@@ -87,7 +87,7 @@ module RSpec
         end
 
         it "calls failure_message if the matcher does not implement failure_message_for_should" do
-          matcher = mock("matcher", :failure_message => "message", :matches? => false)
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
           actual = Object.new
 
           ::RSpec::Expectations.should_receive(:fail_with).with("message")
@@ -96,45 +96,56 @@ module RSpec
 
         end
 
-        it "appends the :or message in the options hash passed to should" do
-          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+        it "uses the custom failure message when one is provided" do
+          matcher = double("matcher", :failure_message_for_should => "message", :matches? => false)
           actual = Object.new
 
           ::RSpec::Expectations.should_receive(:fail_with).with("custom")
 
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom")
         end
+
+        it "uses the custom failure message when one is provided as a callable object" do
+          matcher = double("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+
+          failure_message = double("failure message", :call => "custom")
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, failure_message)
+        end
       end
     end
 
     describe NegativeExpectationHandler do
       describe "#handle_matcher" do
         it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do
-          matcher = mock("matcher", :does_not_match? => true, :negative_failure_message => nil)
+          matcher = double("matcher", :does_not_match? => true, :negative_failure_message => nil)
           actual = Object.new
           matcher.should_receive(:does_not_match?).with(actual).and_return(true)
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do
-          matcher = mock("matcher")
+          matcher = double("matcher")
           actual = Object.new
-          matcher.stub!(:negative_failure_message)
+          matcher.stub(:negative_failure_message)
           matcher.should_receive(:matches?).with(actual).and_return(false)
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "returns the match value" do
-          matcher = mock("matcher")
+          matcher = double("matcher")
           actual = Object.new
           matcher.should_receive(:matches?).with(actual).and_return(false)
-          matcher.stub!(:negative_failure_message).and_return("ignore")
+          matcher.stub(:negative_failure_message).and_return("ignore")
           expect(RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)).to be_false
         end
 
 
         it "calls failure_message_for_should_not if the matcher implements it" do
-          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          matcher = double("matcher", :failure_message_for_should_not => "message", :matches? => true)
           actual = Object.new
 
           ::RSpec::Expectations.should_receive(:fail_with).with("message")
@@ -144,7 +155,7 @@ module RSpec
         end
 
         it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do
-          matcher = mock("matcher", :negative_failure_message => "message", :matches? => true)
+          matcher = double("matcher", :negative_failure_message => "message", :matches? => true)
           actual = Object.new
 
           ::RSpec::Expectations.should_receive(:fail_with).with("message")
@@ -155,7 +166,7 @@ module RSpec
 
 
         it "calls fail if matcher.diffable?" do
-          matcher = mock("matcher",
+          matcher = double("matcher",
             :diffable? => true,
             :failure_message_for_should_not => "message",
             :matches? => true,
@@ -169,8 +180,8 @@ module RSpec
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
         end
 
-        it "appends the :or message in the options hash passed to should" do
-          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+        it "uses the custom failure message when one is provided" do
+          matcher = double("matcher", :failure_message_for_should_not => "message", :matches? => true)
           actual = Object.new
 
           ::RSpec::Expectations.should_receive(:fail_with).with("custom")
@@ -178,6 +189,16 @@ module RSpec
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom")
         end
 
+        it "uses the custom failure message when one is provided as a callable object" do
+          matcher = double("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+
+          failure_message = double("failure message", :call => "custom")
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, failure_message)
+        end
       end
     end
 
@@ -189,10 +210,10 @@ module RSpec
         expect(5).to arbitrary_matcher(:expected => "wrong").with(5)
         expect { expect(5).to arbitrary_matcher(:expected => 4) }.to fail_with("expected 4, got 5")
         expect { expect(5).to arbitrary_matcher(:expected => 5).with(4) }.to fail_with("expected 4, got 5")
-        expect(5).to_not arbitrary_matcher(:expected => 4)
-        expect(5).to_not arbitrary_matcher(:expected => 5).with(4)
-        expect { expect(5).to_not arbitrary_matcher(:expected => 5) }.to fail_with("expected not 5, got 5")
-        expect { expect(5).to_not arbitrary_matcher(:expected => 4).with(5) }.to fail_with("expected not 5, got 5")
+        expect(5).not_to arbitrary_matcher(:expected => 4)
+        expect(5).not_to arbitrary_matcher(:expected => 5).with(4)
+        expect { expect(5).not_to arbitrary_matcher(:expected => 5) }.to fail_with("expected not 5, got 5")
+        expect { expect(5).not_to arbitrary_matcher(:expected => 4).with(5) }.to fail_with("expected not 5, got 5")
       end
 
       it "handles the submitted block" do

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,14 @@ 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 "passes with negative arguments" 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

@@ -72,6 +72,17 @@ describe "expect { ... }.to change(actual, message)" do
       expect {@instance.some_value << 1}.to change(@instance, :some_value)
     end
 
+    it "fails when a predicate on the actual fails" do
+      expect do
+        expect {@instance.some_value << 1}.to change { @instance.some_value }.to be_empty
+      end.to fail_with(/result should have been changed to/)
+    end
+
+    it "passes when a predicate on the actual passes" do
+      @instance.some_value = [1]
+      expect {@instance.some_value.pop}.to change { @instance.some_value }.to be_empty
+    end
+
     it "fails when actual is not modified by the block" do
       expect do
         expect {}.to change(@instance, :some_value)
@@ -156,12 +167,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 +217,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 +548,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