rspec-expectations 3.0.4 → 3.12.3

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

@@ -8,7 +8,9 @@ module RSpec
       # Not intended to be instantiated directly.
       class Output < BaseMatcher
         def initialize(expected)
-          @expected = expected
+          @expected        = expected
+          @actual          = ""
+          @block           = nil
           @stream_capturer = NullCapture
         end
 
@@ -25,6 +27,7 @@ module RSpec
 
         # @api public
         # Tells the matcher to match against stdout.
+        # Works only when the main Ruby process prints to stdout
         def to_stdout
           @stream_capturer = CaptureStdout
           self
@@ -32,11 +35,30 @@ module RSpec
 
         # @api public
         # Tells the matcher to match against stderr.
+        # Works only when the main Ruby process prints to stderr
         def to_stderr
           @stream_capturer = CaptureStderr
           self
         end
 
+        # @api public
+        # Tells the matcher to match against stdout.
+        # Works when subprocesses print to stdout as well.
+        # This is significantly (~30x) slower than `to_stdout`
+        def to_stdout_from_any_process
+          @stream_capturer = CaptureStreamToTempfile.new("stdout", $stdout)
+          self
+        end
+
+        # @api public
+        # Tells the matcher to match against stderr.
+        # Works when subprocesses print to stderr as well.
+        # This is significantly (~30x) slower than `to_stderr`
+        def to_stderr_from_any_process
+          @stream_capturer = CaptureStreamToTempfile.new("stderr", $stderr)
+          self
+        end
+
         # @api private
         # @return [String]
         def failure_message
@@ -72,6 +94,13 @@ module RSpec
           true
         end
 
+        # @api private
+        # Indicates this matcher matches against a block only.
+        # @return [False]
+        def supports_value_expectations?
+          false
+        end
+
       private
 
         def captured?
@@ -91,7 +120,7 @@ module RSpec
 
         def actual_output_description
           return "nothing" unless captured?
-          @actual.inspect
+          actual_formatted
         end
       end
 
@@ -145,6 +174,34 @@ module RSpec
           $stderr = original_stream
         end
       end
+
+      # @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)
+
+          begin
+            captured_stream.sync = true
+            stream.reopen(captured_stream)
+            block.call
+            captured_stream.rewind
+            captured_stream.read
+          ensure
+            stream.reopen(original_stream)
+            captured_stream.close
+            captured_stream.unlink
+          end
+        end
+      end
     end
   end
 end

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

@@ -4,17 +4,33 @@ module RSpec
       # @api private
       # Provides the implementation for `raise_error`.
       # Not intended to be instantiated directly.
+      # rubocop:disable Metrics/ClassLength
+      # rubocop:disable Lint/RescueException
       class RaiseError
         include Composable
 
-        def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+        # Used as a sentinel value to be able to tell when the user did not pass an
+        # argument. We can't use `nil` for that because we need to warn when `nil` is
+        # passed in a different way. It's an Object, not a Module, since Module's `===`
+        # does not evaluate to true when compared to itself.
+        UndefinedValue = Object.new.freeze
+
+        def initialize(expected_error_or_message, expected_message, &block)
           @block = block
           @actual_error = nil
+          @warn_about_bare_error = UndefinedValue === expected_error_or_message
+          @warn_about_nil_error = expected_error_or_message.nil?
+
           case expected_error_or_message
-          when String, Regexp
-            @expected_error, @expected_message = Exception, expected_error_or_message
+          when nil, UndefinedValue
+            @expected_error = Exception
+            @expected_message = expected_message
+          when String
+            @expected_error = Exception
+            @expected_message = expected_error_or_message
           else
-            @expected_error, @expected_message = expected_error_or_message, expected_message
+            @expected_error = expected_error_or_message
+            @expected_message = expected_message
           end
         end
 
@@ -22,11 +38,12 @@ 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
 
-        # rubocop:disable MethodLength
+        # rubocop:disable Metrics/MethodLength
         # @private
         def matches?(given_proc, negative_expectation=false, &block)
           @given_proc = given_proc
@@ -41,23 +58,26 @@ module RSpec
           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
+            warn_about_bare_error! if warn_about_bare_error?
+            warn_about_nil_error! if warn_about_nil_error?
+            eval_block if ready_to_eval_block?
           end
 
           expectation_matched?
         end
-        # rubocop:enable MethodLength
+        # rubocop:enable Metrics/MethodLength
 
         # @private
         def does_not_match?(given_proc)
-          prevent_invalid_expectations
+          warn_for_negative_false_positives!
           !matches?(given_proc, :negative_expectation) && Proc === given_proc
         end
 
@@ -66,10 +86,20 @@ module RSpec
           true
         end
 
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
+        # @private
+        def expects_call_stack_jump?
+          true
+        end
+
         # @api private
         # @return [String]
         def failure_message
-          @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+          @eval_block ? actual_error_message : "expected #{expected_error}#{given_error}"
         end
 
         # @api private
@@ -86,6 +116,12 @@ module RSpec
 
       private
 
+        def actual_error_message
+          return nil unless @actual_error
+
+          @actual_error.respond_to?(:original_message) ? @actual_error.original_message : @actual_error.message
+        end
+
         def expectation_matched?
           error_and_message_match? && block_matches?
         end
@@ -98,6 +134,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
@@ -110,32 +150,87 @@ module RSpec
 
         def verify_message
           return true if @expected_message.nil?
-          values_match?(@expected_message, @actual_error.message)
+          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_negative_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)`"
+                       elsif @warn_about_nil_error
+                         "`expect { }.not_to raise_error(nil)`"
+                       end
 
-          return unless what_to_raise
+          return unless expression
 
-          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
+          warn_about_negative_false_positive! expression
+        end
+
+        def handle_warning(message)
+          RSpec::Expectations.configuration.false_positives_handler.call(message)
+        end
+
+        def warn_about_bare_error?
+          @warn_about_bare_error && @block.nil?
+        end
+
+        def warn_about_nil_error?
+          @warn_about_nil_error
+        end
+
+        def warn_about_bare_error!
+          handle_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. " \
+                         "#{warning}"\
+                         "Instead consider providing a specific error class or message. " \
+                         "This message can be suppressed by setting: " \
+                         "`RSpec::Expectations.configuration.on_potential_false" \
+                         "_positives = :nothing`")
+        end
+
+        def warn_about_nil_error!
+          handle_warning("Using the `raise_error` matcher with a `nil` error is probably " \
+                         "unintentional, it 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. " \
+                         "#{warning}"\
+                         "Instead consider providing a specific error class or message. " \
+                         "This message can be suppressed by setting: " \
+                         "`RSpec::Expectations.configuration.on_potential_false" \
+                         "_positives = :nothing`")
+        end
+
+        def warn_about_negative_false_positive!(expression)
+          handle_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` or `expect { }.to raise_error" \
+                         "(DifferentSpecificErrorClass)`. This message can be suppressed by " \
+                         "setting: `RSpec::Expectations.configuration.on_potential_false" \
+                         "_positives = :nothing`")
         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
 
@@ -150,7 +245,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
@@ -160,9 +255,17 @@ module RSpec
         end
 
         def raise_message_already_set
-          raise "`expect { }.to raise_error(message).with_message(message)` is not valid. The matcher only allows the expected message to be specified once"
+          raise "`expect { }.to raise_error(message).with_message(message)` is not valid. " \
+                'The matcher only allows the expected message to be specified once'
+        end
+
+        def warning
+          warning = "Actual error raised was #{description_of(@actual_error)}. "
+          warning if @actual_error
         end
       end
+      # rubocop:enable Lint/RescueException
+      # rubocop:enable Metrics/ClassLength
     end
   end
 end

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

@@ -6,12 +6,14 @@ module RSpec
       # @api private
       # Provides the implementation for `respond_to`.
       # Not intended to be instantiated directly.
-      class RespondTo
-        include Composable
-
+      class RespondTo < BaseMatcher
         def initialize(*names)
           @names = names
           @expected_arity = nil
+          @expected_keywords = []
+          @ignoring_method_signature_failure = false
+          @unlimited_arguments = nil
+          @arbitrary_keywords = nil
         end
 
         # @api public
@@ -24,6 +26,43 @@ module RSpec
           self
         end
 
+        # @api public
+        # Specifies keyword arguments, if any.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_keywords(:color, :shape)
+        # @example with an expected number of arguments
+        #   expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape)
+        def with_keywords(*keywords)
+          @expected_keywords = keywords
+          self
+        end
+        alias :and_keywords :with_keywords
+
+        # @api public
+        # Specifies that the method accepts any keyword, i.e. the method has
+        #   a splatted keyword parameter of the form **kw_args.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_any_keywords
+        def with_any_keywords
+          @arbitrary_keywords = true
+          self
+        end
+        alias :and_any_keywords :with_any_keywords
+
+        # @api public
+        # Specifies that the number of arguments has no upper limit, i.e. the
+        #   method has a splatted parameter of the form *args.
+        #
+        # @example
+        #   expect(obj).to respond_to(:message).with_unlimited_arguments
+        def with_unlimited_arguments
+          @unlimited_arguments = true
+          self
+        end
+        alias :and_unlimited_arguments :with_unlimited_arguments
+
         # @api public
         # No-op. Intended to be used as syntactic sugar when using `with`.
         #
@@ -47,7 +86,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
@@ -62,9 +101,10 @@ module RSpec
           "respond to #{pp_names}#{with_arity}"
         end
 
-        # @private
-        def supports_block_expectations?
-          false
+        # @api private
+        # Used by other matchers to suppress a check
+        def ignoring_method_signature_failure!
+          @ignoring_method_signature_failure = true
         end
 
       private
@@ -77,20 +117,82 @@ module RSpec
         end
 
         def matches_arity?(actual, name)
-          return true unless @expected_arity
-
-          signature = Support::MethodSignature.new(actual.method(name))
-          Support::MethodSignatureVerifier.new(signature, Array.new(@expected_arity)).valid?
+          ArityCheck.new(@expected_arity, @expected_keywords, @arbitrary_keywords, @unlimited_arguments).matches?(actual, name)
+        rescue NameError
+          return true if @ignoring_method_signature_failure
+          raise ArgumentError, "The #{matcher_name} matcher requires that " \
+                               "the actual object define the method(s) in " \
+                               "order to check arity, but the method " \
+                               "`#{name}` is not defined. Remove the arity " \
+                               "check or define the method to continue."
         end
 
         def with_arity
-          return "" unless @expected_arity
-          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+          str = ''.dup
+          str << " with #{with_arity_string}" if @expected_arity
+          str << " #{str.length == 0 ? 'with' : 'and'} #{with_keywords_string}" if @expected_keywords && @expected_keywords.count > 0
+          str << " #{str.length == 0 ? 'with' : 'and'} unlimited arguments" if @unlimited_arguments
+          str << " #{str.length == 0 ? 'with' : 'and'} any keywords" if @arbitrary_keywords
+          str
+        end
+
+        def with_arity_string
+          "#{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+        end
+
+        def with_keywords_string
+          kw_str = case @expected_keywords.count
+                   when 1
+                     @expected_keywords.first.inspect
+                   when 2
+                     @expected_keywords.map(&:inspect).join(' and ')
+                   else
+                     "#{@expected_keywords[0...-1].map(&:inspect).join(', ')}, and #{@expected_keywords.last.inspect}"
+                   end
+
+          "keyword#{@expected_keywords.count == 1 ? '' : 's'} #{kw_str}"
         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
+
+        # @private
+        class ArityCheck
+          def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments)
+            expectation = Support::MethodSignatureExpectation.new
+
+            if expected_arity.is_a?(Range)
+              expectation.min_count = expected_arity.min
+              expectation.max_count = expected_arity.max
+            else
+              expectation.min_count = expected_arity
+            end
+
+            expectation.keywords = expected_keywords
+            expectation.expect_unlimited_arguments = unlimited_arguments
+            expectation.expect_arbitrary_keywords  = arbitrary_keywords
+            @expectation = expectation
+          end
+
+          def matches?(actual, name)
+            return true if @expectation.empty?
+            verifier_for(actual, name).with_expectation(@expectation).valid?
+          end
+
+          def verifier_for(actual, name)
+            Support::StrictSignatureVerifier.new(method_signature_for(actual, name))
+          end
+
+          def method_signature_for(actual, name)
+            method_handle = Support.method_handle_for(actual, name)
+
+            if name == :new && method_handle.owner === ::Class && ::Class === actual
+              Support::MethodSignature.new(actual.instance_method(:initialize))
+            else
+              Support::MethodSignature.new(method_handle)
+            end
+          end
         end
       end
     end

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

@@ -4,10 +4,9 @@ module RSpec
       # @api private
       # Provides the implementation for `satisfy`.
       # Not intended to be instantiated directly.
-      class Satisfy
-        include Composable
-
-        def initialize(&block)
+      class Satisfy < BaseMatcher
+        def initialize(description=nil, &block)
+          @description = description
           @block = block
         end
 
@@ -18,27 +17,42 @@ module RSpec
           @block.call(actual)
         end
 
+        # @private
+        def description
+          @description ||= "satisfy #{block_representation}"
+        end
+
         # @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"
+          "expected #{actual_formatted} not to #{description}"
         end
 
-        # @api private
-        # @return [String]
-        def description
-          "satisfy block"
-        end
+      private
 
-        # @private
-        def supports_block_expectations?
-          false
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          def block_representation
+            if (block_snippet = extract_block_snippet)
+              "expression `#{block_snippet}`"
+            else
+              'block'
+            end
+          end
+
+          def extract_block_snippet
+            return nil unless @block
+            Expectations::BlockSnippetExtractor.try_extracting_single_line_body_of(@block, matcher_name)
+          end
+        else
+          def block_representation
+            'block'
+          end
         end
       end
     end