rspec-expectations 3.2.1 → 3.3.0

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

@@ -42,7 +42,7 @@ module RSpec
         # @return [String]
         def description
           described_items = surface_descriptions_in(expected)
-          improve_hash_formatting "have attributes #{described_items.inspect}"
+          improve_hash_formatting "have attributes #{RSpec::Support::ObjectFormatter.format(described_items)}"
         end
 
         # @api private
@@ -55,14 +55,14 @@ module RSpec
         # @return [String]
         def failure_message
           respond_to_failure_message_or do
-            "expected #{@actual.inspect} to #{description} but had attributes #{ formatted_values }"
+            "expected #{actual_formatted} to #{description} but had attributes #{ formatted_values }"
           end
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          respond_to_failure_message_or { "expected #{@actual.inspect} not to #{description}" }
+          respond_to_failure_message_or { "expected #{actual_formatted} not to #{description}" }
         end
 
       private
@@ -105,7 +105,8 @@ module RSpec
         end
 
         def formatted_values
-          improve_hash_formatting(@values.inspect)
+          values = RSpec::Support::ObjectFormatter.format(@values)
+          improve_hash_formatting(values)
         end
       end
     end

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

@@ -12,62 +12,78 @@ module RSpec
         # @api private
         # @return [Boolean]
         def matches?(actual)
-          @actual = actual
-          perform_match(:all?, :all?)
+          perform_match(actual) { |v| v }
         end
 
         # @api private
         # @return [Boolean]
         def does_not_match?(actual)
-          @actual = actual
-          perform_match(:none?, :any?)
+          perform_match(actual) { |v| !v }
         end
 
         # @api private
         # @return [String]
         def description
-          described_items = surface_descriptions_in(expected)
-          improve_hash_formatting "include#{to_sentence(described_items)}"
+          improve_hash_formatting("include#{readable_list_of(expected)}")
         end
 
         # @api private
         # @return [String]
         def failure_message
-          improve_hash_formatting(super) + invalid_object_message
+          format_failure_message("to") { super }
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          improve_hash_formatting(super) + invalid_object_message
+          format_failure_message("not to") { super }
         end
 
         # @api private
         # @return [Boolean]
         def diffable?
-          true
+          !diff_would_wrongly_highlight_matched_item?
         end
 
       private
 
-        def invalid_object_message
-          return '' if actual.respond_to?(:include?)
-          ", but it does not respond to `include?`"
+        def format_failure_message(preposition)
+          if actual.respond_to?(:include?)
+            improve_hash_formatting("expected #{description_of @actual} #{preposition} include#{readable_list_of @divergent_items}")
+          else
+            improve_hash_formatting(yield) + ", but it does not respond to `include?`"
+          end
         end
 
-        def perform_match(predicate, hash_subset_predicate)
-          return false unless actual.respond_to?(:include?)
+        def readable_list_of(items)
+          described_items = surface_descriptions_in(items)
+          if described_items.all? { |item| item.is_a?(Hash) }
+            " #{described_items.inject(:merge).inspect}"
+          else
+            EnglishPhrasing.list(described_items)
+          end
+        end
 
-          expected.__send__(predicate) do |expected_item|
+        def perform_match(actual, &block)
+          @actual = actual
+          @divergent_items = excluded_from_actual(&block)
+          actual.respond_to?(:include?) && @divergent_items.empty?
+        end
+
+        def excluded_from_actual
+          return [] unless @actual.respond_to?(:include?)
+
+          expected.inject([]) do |memo, expected_item|
             if comparing_hash_to_a_subset?(expected_item)
-              expected_item.__send__(hash_subset_predicate) do |(key, value)|
-                actual_hash_includes?(key, value)
+              expected_item.each do |(key, value)|
+                memo << { key => value } unless yield actual_hash_includes?(key, value)
               end
             elsif comparing_hash_keys?(expected_item)
-              actual_hash_has_key?(expected_item)
+              memo << expected_item unless yield actual_hash_has_key?(expected_item)
             else
-              actual_collection_includes?(expected_item)
+              memo << expected_item unless yield actual_collection_includes?(expected_item)
             end
+            memo
           end
         end
 
@@ -99,6 +115,15 @@ module RSpec
 
           actual.any? { |value| values_match?(expected_item, value) }
         end
+
+        def diff_would_wrongly_highlight_matched_item?
+          return false unless actual.is_a?(String) && expected.is_a?(Array)
+
+          lines = actual.split("\n")
+          expected.any? do |str|
+            actual.include?(str) && lines.none? { |line| line == str }
+          end
+        end
       end
     end
   end

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

@@ -21,7 +21,15 @@ module RSpec
 
         def match(expected, actual)
           return true if values_match?(expected, actual)
-          actual.match(expected) if actual.respond_to?(:match)
+          return false unless can_safely_call_match?(expected, actual)
+          actual.match(expected)
+        end
+
+        def can_safely_call_match?(expected, actual)
+          return false unless actual.respond_to?(:match)
+
+          !(RSpec::Matchers.is_a_matcher?(expected) &&
+            (String === actual || Regexp === actual))
         end
       end
     end

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

@@ -74,7 +74,7 @@ module RSpec
         # @api private
         # @return [String]
         def description
-          "#{@operator} #{@expected.inspect}"
+          "#{@operator} #{RSpec::Support::ObjectFormatter.format(@expected)}"
         end
 
       private
@@ -98,10 +98,15 @@ module RSpec
         def __delegate_operator(actual, operator, expected)
           if actual.__send__(operator, expected)
             true
-          elsif ['==', '===', '=~'].include?(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}")
+            expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
+            actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
+
+            if ['==', '===', '=~'].include?(operator)
+              fail_with_message("expected: #{expected_formatted}\n     got: #{actual_formatted} (using #{operator})")
+            else
+              fail_with_message("expected: #{operator} #{expected_formatted}\n     got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
+            end
           end
         end
       end
@@ -111,7 +116,11 @@ module RSpec
       class NegativeOperatorMatcher < OperatorMatcher
         def __delegate_operator(actual, operator, expected)
           return false unless actual.__send__(operator, expected)
-          fail_with_message("expected not: #{operator} #{expected.inspect}\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+
+          expected_formatted = RSpec::Support::ObjectFormatter.format(expected)
+          actual_formatted   = RSpec::Support::ObjectFormatter.format(actual)
+
+          fail_with_message("expected not: #{operator} #{expected_formatted}\n         got: #{operator.gsub(/./, ' ')} #{actual_formatted}")
         end
       end
     end

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

@@ -1,5 +1,4 @@
 require 'stringio'
-require 'tempfile'
 
 module RSpec
   module Matchers
@@ -114,7 +113,7 @@ module RSpec
 
         def actual_output_description
           return "nothing" unless captured?
-          @actual.inspect
+          actual_formatted
         end
       end
 
@@ -172,6 +171,14 @@ module RSpec
       # @private
       class CaptureStreamToTempfile < Struct.new(:name, :stream)
         def capture(block)
+          # We delay loading tempfile until it is actually needed because
+          # we want to minimize stdlibs loaded so that users who use a
+          # portion of the stdlib can't have passing specs while forgetting
+          # to load it themselves. `CaptureStreamToTempfile` is rarely used
+          # and `tempfile` pulls in a bunch of things (delegate, tmpdir,
+          # thread, fileutils, etc), so it's worth delaying it until this point.
+          require 'tempfile'
+
           original_stream = stream.clone
           captured_stream = Tempfile.new(name)
 

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

@@ -8,11 +8,15 @@ module RSpec
       class RaiseError
         include Composable
 
-        def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+        def initialize(expected_error_or_message=nil, expected_message=nil, &block)
           @block = block
           @actual_error = nil
+          @warn_about_bare_error = warn_about_potential_false_positives? && expected_error_or_message.nil?
+
           case expected_error_or_message
-          when String, Regexp
+          when nil
+            @expected_error, @expected_message = Exception, expected_message
+          when String
             @expected_error, @expected_message = Exception, expected_error_or_message
           else
             @expected_error, @expected_message = expected_error_or_message, expected_message
@@ -23,6 +27,7 @@ module RSpec
         # Specifies the expected error message.
         def with_message(expected_message)
           raise_message_already_set if @expected_message
+          @warn_about_bare_error = false
           @expected_message = expected_message
           self
         end
@@ -37,20 +42,20 @@ module RSpec
           @eval_block = false
           @eval_block_passed = false
 
+          warn_about_bare_error if warning_about_bare_error && !negative_expectation
           return false unless Proc === given_proc
 
           begin
             given_proc.call
           rescue Exception => @actual_error
-            if values_match?(@expected_error, @actual_error)
+            if values_match?(@expected_error, @actual_error) ||
+               values_match?(@expected_error, @actual_error.message)
               @raised_expected_error = true
               @with_expected_message = verify_message
             end
           end
 
-          unless negative_expectation
-            eval_block if @raised_expected_error && @with_expected_message && @block
-          end
+          eval_block if !negative_expectation && ready_to_eval_block?
 
           expectation_matched?
         end
@@ -58,7 +63,7 @@ module RSpec
 
         # @private
         def does_not_match?(given_proc)
-          prevent_invalid_expectations
+          warn_for_false_positives
           !matches?(given_proc, :negative_expectation) && Proc === given_proc
         end
 
@@ -103,6 +108,10 @@ module RSpec
           @eval_block ? @eval_block_passed : true
         end
 
+        def ready_to_eval_block?
+          @raised_expected_error && @with_expected_message && @block
+        end
+
         def eval_block
           @eval_block = true
           begin
@@ -118,29 +127,62 @@ module RSpec
           values_match?(@expected_message, @actual_error.message.to_s)
         end
 
-        def prevent_invalid_expectations
-          what_to_raise = 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
+        def warn_for_false_positives
+          return unless warn_about_potential_false_positives?
+          expression = 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
+
+          return unless expression
+
+          warn_about_negative_false_positive expression
+        end
+
+        def warn_about_potential_false_positives?
+          RSpec::Expectations.configuration.warn_about_potential_false_positives?
+        end
 
-          return unless what_to_raise
+        def warning_about_bare_error
+          @warn_about_bare_error && @block.nil?
+        end
 
-          specific_class_error = ArgumentError.new("#{what_to_raise} is not valid, use `expect { }.not_to raise_error` (with no args) instead")
-          raise specific_class_error
+        def warn_about_bare_error
+          RSpec.warning("Using the `raise_error` matcher without providing a specific " \
+                        "error or message risks false positives, since `raise_error` " \
+                        "will match when Ruby raises a `NoMethodError`, `NameError` or " \
+                        "`ArgumentError`, potentially allowing the expectation to pass " \
+                        "without even executing the method you are intending to call. " \
+                        "Instead consider providing a specific error class or message. " \
+                        "This message can be supressed by setting: " \
+                        "`RSpec::Expectations.configuration.warn_about_potential_false_positives = false`")
+        end
+
+        def warn_about_negative_false_positive(expression)
+          RSpec.warning("Using #{expression} risks false positives, since literally " \
+                        "any other error would cause the expectation to pass, " \
+                        "including those raised by Ruby (e.g. NoMethodError, NameError " \
+                        "and ArgumentError), meaning the code you are intending to test " \
+                        "may not even get reached. Instead consider using " \
+                        "`expect {}.not_to raise_error`. This message can be supressed by setting: " \
+                        "`RSpec::Expectations.configuration.warn_about_potential_false_positives = false`")
         end
 
         def expected_error
           case @expected_message
           when nil
-            description_of(@expected_error)
+            if RSpec::Support.is_a_matcher?(@expected_error)
+              "Exception with #{description_of(@expected_error)}"
+            else
+              description_of(@expected_error)
+            end
           when Regexp
-            "#{@expected_error} with message matching #{@expected_message.inspect}"
+            "#{@expected_error} with message matching #{description_of(@expected_message)}"
           else
-            "#{@expected_error} with #{description_of @expected_message}"
+            "#{@expected_error} with #{description_of(@expected_message)}"
           end
         end
 
@@ -155,7 +197,7 @@ module RSpec
 
           backtrace = format_backtrace(@actual_error.backtrace)
           [
-            ", got #{@actual_error.inspect} with backtrace:",
+            ", got #{description_of(@actual_error)} with backtrace:",
             *backtrace
           ].join("\n  # ")
         end

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

@@ -45,7 +45,7 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected #{@actual.inspect} to respond to #{@failing_method_names.map { |name| name.inspect }.join(', ')}#{with_arity}"
+          "expected #{actual_formatted} to respond to #{@failing_method_names.map { |name| description_of(name) }.join(', ')}#{with_arity}"
         end
 
         # @api private
@@ -82,8 +82,7 @@ module RSpec
         end
 
         def pp_names
-          # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
-          @names.length == 1 ? "##{@names.first}" : @names.inspect
+          @names.length == 1 ? "##{@names.first}" : description_of(@names)
         end
       end
     end

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

@@ -5,7 +5,11 @@ module RSpec
       # Provides the implementation for `satisfy`.
       # Not intended to be instantiated directly.
       class Satisfy < BaseMatcher
-        def initialize(&block)
+        # @private
+        attr_reader :description
+
+        def initialize(description="satisfy block", &block)
+          @description = description
           @block = block
         end
 
@@ -19,19 +23,13 @@ module RSpec
         # @api private
         # @return [String]
         def failure_message
-          "expected #{@actual} to satisfy block"
+          "expected #{actual_formatted} to #{description}"
         end
 
         # @api private
         # @return [String]
         def failure_message_when_negated
-          "expected #{@actual} not to satisfy block"
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "satisfy block"
+          "expected #{actual_formatted} not to #{description}"
         end
       end
     end

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

@@ -26,7 +26,9 @@ module RSpec
         # @return [String]
         def description
           return super unless Hash === expected
-          "#{name_to_sentence} #{surface_descriptions_in(expected).inspect}"
+          english_name = EnglishPhrasing.split_words(self.class.matcher_name)
+          description_of_expected = surface_descriptions_in(expected).inspect
+          "#{english_name} #{description_of_expected}"
         end
 
       private