rspec-expectations 2.13.0 → 2.14.0.rc1

data/lib/rspec/matchers/be_close.rb

@@ -2,7 +2,7 @@ module RSpec
   module Matchers
     # @deprecated use +be_within+ instead.
     def be_close(expected, delta)
-      RSpec.deprecate("be_close(#{expected}, #{delta})", "be_within(#{delta}).of(#{expected})")
+      RSpec.deprecate("be_close(#{expected}, #{delta})", :replacement => "be_within(#{delta}).of(#{expected})")
       be_within(delta).of(expected)
     end
   end

data/lib/rspec/matchers/built_in/be_within.rb

@@ -23,7 +23,7 @@ module RSpec
 
         def percent_of(expected)
           @expected  = expected
-          @tolerance = @delta * @expected / 100
+          @tolerance = @delta * @expected / 100.0
           @unit      = '%'
           self
         end

data/lib/rspec/matchers/built_in/have.rb

@@ -2,6 +2,8 @@ module RSpec
   module Matchers
     module BuiltIn
       class Have
+        QUERY_METHODS = [:size, :length, :count].freeze
+
         def initialize(expected, relativity=:exactly)
           @expected = case expected
                       when :no then 0
@@ -22,9 +24,19 @@ module RSpec
 
         def matches?(collection_or_owner)
           collection = determine_collection(collection_or_owner)
-          query_method = determine_query_method(collection)
-          raise not_a_collection unless query_method
-          @actual = collection.__send__(query_method)
+          case collection
+          when enumerator_class
+            for query_method in QUERY_METHODS
+              next unless collection.respond_to?(query_method)
+              @actual = collection.__send__(query_method)
+              break unless @actual.nil?
+            end
+            raise not_a_collection if @actual.nil?
+          else
+            query_method = determine_query_method(collection)
+            raise not_a_collection unless query_method
+            @actual = collection.__send__(query_method)
+          end
           case @relativity
           when :at_least then @actual >= @expected
           when :at_most  then @actual <= @expected
@@ -46,7 +58,7 @@ module RSpec
         end
 
         def determine_query_method(collection)
-          [:size, :length, :count].detect {|m| collection.respond_to?(m)}
+          QUERY_METHODS.detect {|m| collection.respond_to?(m)}
         end
 
         def not_a_collection
@@ -102,6 +114,10 @@ EOF
         def relative_expectation
           "#{relativities[@relativity]}#{@expected}"
         end
+
+        def enumerator_class
+          RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+        end
       end
     end
   end

data/lib/rspec/matchers/built_in/raise_error.rb

@@ -14,19 +14,31 @@ module RSpec
         end
 
         def matches?(given_proc, negative_expectation = false)
+          if negative_expectation && (expecting_specific_exception? || @expected_message)
+            what_to_deprecate = if expecting_specific_exception? && @expected_message
+                                  "`expect { }.not_to raise_error(SpecificErrorClass, message)`"
+                                elsif expecting_specific_exception?
+                                  "`expect { }.not_to raise_error(SpecificErrorClass)`"
+                                elsif @expected_message
+                                  "`expect { }.not_to raise_error(message)`"
+                                end
+            RSpec.deprecate(what_to_deprecate, :replacement => "`expect { }.not_to raise_error()`")
+          end
           @raised_expected_error = false
           @with_expected_message = false
           @eval_block = false
           @eval_block_passed = false
+          unless given_proc.respond_to?(:call)
+            ::Kernel.warn "`raise_error` was called with non-proc object #{given_proc.inspect}"
+            return false
+          end
           begin
             given_proc.call
-          rescue @expected_error => @actual_error
-            @raised_expected_error = true
-            @with_expected_message = verify_message
           rescue Exception => @actual_error
-            # This clause should be empty, but rcov will not report it as covered
-            # unless something (anything) is executed within the clause
-            "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+            if @actual_error == @expected_error || @expected_error === @actual_error
+              @raised_expected_error = true
+              @with_expected_message = verify_message
+            end
           end
 
           unless negative_expectation
@@ -79,7 +91,7 @@ module RSpec
         def expected_error
           case @expected_message
           when nil
-            @expected_error
+            @expected_error.inspect
           when Regexp
             "#{@expected_error} with message matching #{@expected_message.inspect}"
           else
@@ -101,6 +113,10 @@ module RSpec
             *backtrace
           ].join("\n  # ")
         end
+
+        def expecting_specific_exception?
+          @expected_error != Exception
+        end
       end
     end
   end

data/lib/rspec/matchers/built_in/yield.rb

@@ -65,17 +65,92 @@ module RSpec
       end
 
       class YieldControl < BaseMatcher
+        def initialize
+          @expectation_type = nil
+          @expected_yields_count = nil
+        end
+
         def matches?(block)
           probe = YieldProbe.probe(block)
-          probe.yielded_once?(:yield_control)
+
+          if @expectation_type
+            probe.num_yields.send(@expectation_type, @expected_yields_count)
+          else
+            probe.yielded_once?(:yield_control)
+          end
+        end
+
+        def once
+          exactly(1)
+          self
+        end
+
+        def twice
+          exactly(2)
+          self
+        end
+
+        def exactly(number)
+          set_expected_yields_count(:==, number)
+          self
+        end
+
+        def at_most(number)
+          set_expected_yields_count(:<=, number)
+          self
+        end
+
+        def at_least(number)
+          set_expected_yields_count(:>=, number)
+          self
+        end
+
+        def times
+          self
         end
 
         def failure_message_for_should
-          "expected given block to yield control"
+          'expected given block to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
         end
 
         def failure_message_for_should_not
-          "expected given block not to yield control"
+          'expected given block not to yield control'.tap do |failure_message|
+            failure_message << relativity_failure_message
+          end
+        end
+
+        private
+
+        def set_expected_yields_count(relativity, n)
+          @expectation_type = relativity
+          @expected_yields_count = case n
+                                   when Numeric then n
+                                   when :once then 1
+                                   when :twice then 2
+                                   end
+        end
+
+        def relativity_failure_message
+          return '' unless @expected_yields_count
+          " #{human_readable_expecation_type}#{human_readable_count}"
+        end
+
+        def human_readable_expecation_type
+          case @expectation_type
+          when :<= then 'at most '
+          when :>= then 'at least '
+          else ''
+          end
+        end
+
+        def human_readable_count
+          case @expected_yields_count
+          when 1 then "once"
+          when 2 then "twice"
+          else "#{@expected_yields_count} times"
+          end
         end
       end
 

data/lib/rspec/matchers/operator_matcher.rb

@@ -91,7 +91,7 @@ module RSpec
           if actual.__send__(operator, expected)
             true
           elsif ['==','===', '=~'].include?(operator)
-            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})") 
+            fail_with_message("expected: #{expected.inspect}\n     got: #{actual.inspect} (using #{operator})")
           else
             fail_with_message("expected: #{operator} #{expected.inspect}\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
           end

data/lib/rspec/matchers/test_unit_integration.rb

@@ -0,0 +1,11 @@
+# Include Matchers for other test frameworks.  Note that MiniTest _must_
+# come before TU because on ruby 1.9, T::U::TC is a subclass of MT::U::TC
+# and a 1.9 bug can lead to infinite recursion from the `super` call in our
+# method_missing hook.  See this gist for more info:
+# https://gist.github.com/845896
+if defined?(MiniTest::Unit::TestCase)
+  MiniTest::Unit::TestCase.send(:include, RSpec::Matchers)
+end
+if defined?(Test::Unit::TestCase)
+  Test::Unit::TestCase.send(:include, RSpec::Matchers)
+end

data/spec/rspec/expectations/differ_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 require 'ostruct'
 
@@ -13,10 +14,11 @@ module RSpec
         # color disabled context
 
       describe '#diff_as_string' do
+        subject { differ.diff_as_string(@expected, @actual) }
         it "outputs unified diff of two strings" do
-          expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
-          actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
-          expected_diff= <<'EOD'
+          @expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          @actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expect(subject).to eql(<<-'EOD')
 
 
 @@ -1,6 +1,6 @@
@@ -35,8 +37,28 @@ module RSpec
  line
 EOD
 
-          diff = differ.diff_as_string(expected, actual)
-          expect(diff).to eql(expected_diff)
+        end
+        if RUBY_VERSION.to_f > 1.9
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION < '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql(<<-EOD.encode('UTF-16LE'))
+
+@@ -1,2 +1,2 @@
+-Tu avec carte {count} item has
++Tu avec carté {count} itém has
+EOD
+          end
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION >= '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql 'Could not produce a diff because of the encoding of the string (UTF-16LE)'
+          end
+          it 'ouputs a message when encountering differently encoded strings' do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has"
+            expect(subject).to eql 'Could not produce a diff because the encoding of the actual string (UTF-8) differs from the encoding of the expected string (UTF-16LE)'
+          end
         end
       end
 

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -37,10 +37,13 @@ module RSpec
         end
 
         it 'passes a valid negative expectation' do
-          expect(5).to_not eq(4)
           expect(5).not_to eq(4)
         end
 
+        it 'passes a valid negative expectation with a split infinitive' do
+          expect(5).to_not eq(4)
+        end
+
         it 'fails an invalid positive expectation' do
           expect {
             expect(5).to eq(4)
@@ -50,10 +53,14 @@ module RSpec
         it 'fails an invalid negative expectation' do
           message = /expected 5 not to be a kind of Fixnum/
           expect {
-            expect(5).to_not be_a(Fixnum)
+            expect(5).not_to be_a(Fixnum)
           }.to fail_with(message)
+        end
+
+        it 'fails an invalid negative expectation with a split infinitive' do
+          message = /expected 5 not to be a kind of Fixnum/
           expect {
-            expect(5).not_to be_a(Fixnum)
+            expect(5).to_not be_a(Fixnum)
           }.to fail_with(message)
         end
 

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