rspec-core 3.0.4 → 3.12.2

data/lib/rspec/core/notifications.rb

@@ -1,12 +1,16 @@
+RSpec::Support.require_rspec_core "formatters/console_codes"
+RSpec::Support.require_rspec_core "formatters/exception_presenter"
 RSpec::Support.require_rspec_core "formatters/helpers"
+RSpec::Support.require_rspec_core "shell_escape"
 
 module RSpec::Core
   # Notifications are value objects passed to formatters to provide them
   # with information about a particular event of interest.
   module Notifications
-
     # @private
-    class NullColorizer
+    module NullColorizer
+      module_function
+
       def wrap(line, _code_or_symbol)
         line
       end
@@ -31,17 +35,26 @@ module RSpec::Core
     #   end
     #
     # @attr example [RSpec::Core::Example] the current example
-    ExampleNotification = Struct.new(:example) do
+    ExampleNotification = Struct.new(:example)
+    class ExampleNotification
       # @private
       def self.for(example)
-        if example.execution_result.pending_fixed?
-          PendingExampleFixedNotification.new(example)
-        elsif example.execution_result.status == :failed
-          FailedExampleNotification.new(example)
-        else
-          new(example)
-        end
+        execution_result = example.execution_result
+
+        return SkippedExampleNotification.new(example) if execution_result.example_skipped?
+        return new(example) unless execution_result.status == :pending || execution_result.status == :failed
+
+        klass = if execution_result.pending_fixed?
+                  PendingExampleFixedNotification
+                elsif execution_result.status == :pending
+                  PendingExampleFailedAsExpectedNotification
+                else
+                  FailedExampleNotification
+                end
+
+        klass.new(example)
       end
+
       private_class_method :new
     end
 
@@ -54,62 +67,63 @@ module RSpec::Core
     #   end
     #
     class ExamplesNotification
-
       def initialize(reporter)
         @reporter = reporter
       end
 
-      # @return [Array(RSpec::Core::Example)] list of examples
+      # @return [Array<RSpec::Core::Example>] list of examples
       def examples
         @reporter.examples
       end
 
-      # @return [Array(RSpec::Core::Example)] list of failed examples
+      # @return [Array<RSpec::Core::Example>] list of failed examples
       def failed_examples
         @reporter.failed_examples
       end
 
-      # @return [Array(RSpec::Core::Example)] list of pending examples
+      # @return [Array<RSpec::Core::Example>] list of pending examples
       def pending_examples
         @reporter.pending_examples
       end
 
-      # @return [Array(Rspec::Core::Notifications::ExampleNotification]
+      # @return [Array<RSpec::Core::Notifications::ExampleNotification>]
       #         returns examples as notifications
       def notifications
-        @notifications ||= format(examples)
+        @notifications ||= format_examples(examples)
       end
 
-      # @return [Array(Rspec::Core::Notifications::FailedExampleNotification]
+      # @return [Array<RSpec::Core::Notifications::FailedExampleNotification>]
       #         returns failed examples as notifications
       def failure_notifications
-        @failed_notifications ||= format(failed_examples)
+        @failed_notifications ||= format_examples(failed_examples)
       end
 
-      # @return [String] The list of failed examples, fully formatted in the way that
-      #   RSpec's built-in formatters emit.
-      def fully_formatted_failed_examples(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
+      # @return [Array<RSpec::Core::Notifications::SkippedExampleNotification,
+      #                 RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification>]
+      #         returns pending examples as notifications
+      def pending_notifications
+        @pending_notifications ||= format_examples(pending_examples)
+      end
+
+      # @return [String] The list of failed examples, fully formatted in the way
+      #   that RSpec's built-in formatters emit.
+      def fully_formatted_failed_examples(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
         formatted = "\nFailures:\n"
 
         failure_notifications.each_with_index do |failure, index|
-          formatted << failure.fully_formatted(index.next, colorizer)
+          formatted += failure.fully_formatted(index.next, colorizer)
         end
 
         formatted
       end
 
-      # @return [String] The list of pending examples, fully formatted in the way that
-      #   RSpec's built-in formatters emit.
-      def fully_formatted_pending_examples(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
-        formatted = "\nPending:\n"
-
-        pending_examples.each do |example|
-          formatted_caller = RSpec.configuration.backtrace_formatter.backtrace_line(example.location)
+      # @return [String] The list of pending examples, fully formatted in the
+      #   way that RSpec's built-in formatters emit.
+      def fully_formatted_pending_examples(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        formatted = "\nPending: (Failures listed here are expected and do not affect your suite's status)\n".dup
 
-          formatted <<
-            "  #{colorizer.wrap(example.full_description, :pending)}\n" <<
-            "    # #{colorizer.wrap(example.execution_result.pending_message, :detail)}\n" <<
-            "    # #{colorizer.wrap(formatted_caller, :detail)}\n"
+        pending_notifications.each_with_index do |notification, index|
+          formatted << notification.fully_formatted(index.next, colorizer)
         end
 
         formatted
@@ -117,16 +131,16 @@ module RSpec::Core
 
     private
 
-      def format(examples)
+      def format_examples(examples)
         examples.map do |example|
           ExampleNotification.for(example)
         end
       end
-
     end
 
     # The `FailedExampleNotification` extends `ExampleNotification` with
-    # things useful for failed specs.
+    # things useful for examples that have failure info -- typically a
+    # failed or pending spec.
     #
     # @example
     #   def example_failed(notification)
@@ -142,173 +156,97 @@ module RSpec::Core
 
       # @return [Exception] The example failure
       def exception
-        example.execution_result.exception
+        @exception_presenter.exception
       end
 
       # @return [String] The example description
       def description
-        example.full_description
+        @exception_presenter.description
       end
 
       # Returns the message generated for this failure line by line.
       #
-      # @return [Array(String)] The example failure message
+      # @return [Array<String>] The example failure message
       def message_lines
-        add_shared_group_line(failure_lines, NullColorizer)
+        @exception_presenter.message_lines
       end
 
       # Returns the message generated for this failure colorized line by line.
       #
       # @param colorizer [#wrap] An object to colorize the message_lines by
-      # @return [Array(String)] The example failure message colorized
-      def colorized_message_lines(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
-        add_shared_group_line(failure_lines, colorizer).map do |line|
-          colorizer.wrap line, RSpec.configuration.failure_color
-        end
+      # @return [Array<String>] The example failure message colorized
+      def colorized_message_lines(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        @exception_presenter.colorized_message_lines(colorizer)
       end
 
       # Returns the failures formatted backtrace.
       #
-      # @return [Array(String)] the examples backtrace lines
+      # @return [Array<String>] the examples backtrace lines
       def formatted_backtrace
-        backtrace_formatter.format_backtrace(exception.backtrace, example.metadata)
+        @exception_presenter.formatted_backtrace
       end
 
       # Returns the failures colorized formatted backtrace.
       #
       # @param colorizer [#wrap] An object to colorize the message_lines by
-      # @return [Array(String)] the examples colorized backtrace lines
-      def colorized_formatted_backtrace(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
-        formatted_backtrace.map do |backtrace_info|
-          colorizer.wrap "# #{backtrace_info}", RSpec.configuration.detail_color
-        end
+      # @return [Array<String>] the examples colorized backtrace lines
+      def colorized_formatted_backtrace(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        @exception_presenter.colorized_formatted_backtrace(colorizer)
       end
 
       # @return [String] The failure information fully formatted in the way that
       #   RSpec's built-in formatters emit.
-      def fully_formatted(failure_number, colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
-        formatted = "\n  #{failure_number}) #{description}\n"
-
-        colorized_message_lines(colorizer).each do |line|
-          formatted << "     #{line}\n"
-        end
-
-        colorized_formatted_backtrace(colorizer).each do |line|
-          formatted << "     #{line}\n"
-        end
-
-        formatted
-      end
-
-    private
-
-      def backtrace_formatter
-        RSpec.configuration.backtrace_formatter
+      def fully_formatted(failure_number, colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        @exception_presenter.fully_formatted(failure_number, colorizer)
       end
 
-      def exception_class_name
-        name = exception.class.name.to_s
-        name ="(anonymous error class)" if name == ''
-        name
+      # @return [Array<string>] The failure information fully formatted in the way that
+      #   RSpec's built-in formatters emit, split by line.
+      def fully_formatted_lines(failure_number, colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        @exception_presenter.fully_formatted_lines(failure_number, colorizer)
       end
 
-      def failure_lines
-        @failure_lines ||=
-          begin
-            lines = ["Failure/Error: #{read_failed_line.strip}"]
-            lines << "#{exception_class_name}:" unless exception_class_name =~ /RSpec/
-            exception.message.to_s.split("\n").each do |line|
-              lines << "  #{line}" if exception.message
-            end
-            lines
-          end
-      end
-
-      def add_shared_group_line(lines, colorizer)
-        unless shared_group_line == ""
-          lines << colorizer.wrap(shared_group_line, RSpec.configuration.default_color)
-        end
-        lines
-      end
-
-      def shared_group
-        @shared_group ||= group_and_parent_groups.find { |group| group.metadata[:shared_group_name] }
-      end
-
-      def shared_group_line
-        @shared_group_line ||=
-          if shared_group
-             "Shared Example Group: \"#{shared_group.metadata[:shared_group_name]}\"" +
-              " called from #{backtrace_formatter.backtrace_line(shared_group.location)}"
-          else
-            ""
-          end
-      end
+    private
 
-      def group_and_parent_groups
-        example.example_group.parent_groups + [example.example_group]
+      def initialize(example, exception_presenter=Formatters::ExceptionPresenter::Factory.new(example).build)
+        @exception_presenter = exception_presenter
+        super(example)
       end
+    end
 
-      def read_failed_line
-        unless matching_line = find_failed_line
-          return "Unable to find matching line from backtrace"
-        end
-
-        file_path, line_number = matching_line.match(/(.+?):(\d+)(|:\d+)/)[1..2]
-
-        if File.exist?(file_path)
-          File.readlines(file_path)[line_number.to_i - 1] ||
-            "Unable to find matching line in #{file_path}"
-        else
-          "Unable to find #{file_path} to read failed line"
-        end
-      rescue SecurityError
-        "Unable to read failed line"
-      end
+    # @deprecated Use {FailedExampleNotification} instead.
+    class PendingExampleFixedNotification < FailedExampleNotification; end
 
-      def find_failed_line
-        path = File.expand_path(example.file_path)
-        exception.backtrace.detect do |line|
-          match = line.match(/(.+?):(\d+)(|:\d+)/)
-          match && match[1].downcase == path.downcase
-        end
-      end
-    end
+    # @deprecated Use {FailedExampleNotification} instead.
+    class PendingExampleFailedAsExpectedNotification < FailedExampleNotification; end
 
-    # The `PendingExampleFixedNotification` extends `ExampleNotification` with
-    # things useful for specs that pass when they are expected to fail.
+    # The `SkippedExampleNotification` extends `ExampleNotification` with
+    # things useful for specs that are skipped.
     #
     # @attr [RSpec::Core::Example] example the current example
     # @see ExampleNotification
-    class PendingExampleFixedNotification < FailedExampleNotification
+    class SkippedExampleNotification < ExampleNotification
       public_class_method :new
 
-      # Returns the examples description
-      #
-      # @return [String] The example description
-      def description
-        "#{example.full_description} FIXED"
-      end
-
-      # Returns the message generated for this failure line by line.
-      #
-      # @return [Array(String)] The example failure message
-      def message_lines
-        ["Expected pending '#{example.execution_result.pending_message}' to fail. No Error was raised."]
-      end
+      # @return [String] The pending detail fully formatted in the way that
+      #   RSpec's built-in formatters emit.
+      def fully_formatted(pending_number, colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        formatted_caller = RSpec.configuration.backtrace_formatter.backtrace_line(example.location)
 
-      # Returns the message generated for this failure colorized line by line.
-      #
-      # @param colorizer [#wrap] An object to colorize the message_lines by
-      # @return [Array(String)] The example failure message colorized
-      def colorized_message_lines(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
-        message_lines.map { |line| colorizer.wrap(line, RSpec.configuration.fixed_color) }
+        [
+          colorizer.wrap("\n  #{pending_number}) #{example.full_description}", :pending),
+          "\n     ",
+          Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER.call(example, colorizer),
+          "\n",
+          colorizer.wrap("     # #{formatted_caller}\n", :detail)
+        ].join("")
       end
     end
 
-    # The `GroupNotification` represents notifications sent by the reporter which
-    # contain information about the currently running (or soon to be) example group
-    # It is used by formatters to access information about that group.
+    # The `GroupNotification` represents notifications sent by the reporter
+    # which contain information about the currently running (or soon to be)
+    # example group. It is used by formatters to access information about that
+    # group.
     #
     # @example
     #   def example_group_started(notification)
@@ -324,11 +262,12 @@ module RSpec::Core
     MessageNotification = Struct.new(:message)
 
     # The `SeedNotification` holds the seed used to randomize examples and
-    # wether that seed has been used or not.
+    # whether that seed has been used or not.
     #
     # @attr seed [Fixnum] the seed used to randomize ordering
-    # @attr used [Boolean] wether the seed has been used or not
-    SeedNotification = Struct.new(:seed, :used) do
+    # @attr used [Boolean] whether the seed has been used or not
+    SeedNotification = Struct.new(:seed, :used)
+    class SeedNotification
       # @api
       # @return [Boolean] has the seed been used?
       def seed_used?
@@ -339,7 +278,7 @@ module RSpec::Core
       # @return [String] The seed information fully formatted in the way that
       #   RSpec's built-in formatters emit.
       def fully_formatted
-        "\nRandomized with seed #{seed}\n\n"
+        "\nRandomized with seed #{seed}\n"
       end
     end
 
@@ -348,13 +287,18 @@ module RSpec::Core
     # of the test run.
     #
     # @attr duration [Float] the time taken (in seconds) to run the suite
-    # @attr examples [Array(RSpec::Core::Example)] the examples run
-    # @attr failed_examples [Array(RSpec::Core::Example)] the failed examples
-    # @attr pending_examples [Array(RSpec::Core::Example)] the pending examples
+    # @attr examples [Array<RSpec::Core::Example>] the examples run
+    # @attr failed_examples [Array<RSpec::Core::Example>] the failed examples
+    # @attr pending_examples [Array<RSpec::Core::Example>] the pending examples
     # @attr load_time [Float] the number of seconds taken to boot RSpec
     #                         and load the spec files
-    SummaryNotification = Struct.new(:duration, :examples, :failed_examples, :pending_examples, :load_time) do
-
+    # @attr errors_outside_of_examples_count [Integer] the number of errors that
+    #                                                  have occurred processing
+    #                                                  the spec suite
+    SummaryNotification = Struct.new(:duration, :examples, :failed_examples,
+                                     :pending_examples, :load_time,
+                                     :errors_outside_of_examples_count)
+    class SummaryNotification
       # @api
       # @return [Fixnum] the number of examples run
       def example_count
@@ -376,9 +320,16 @@ module RSpec::Core
       # @api
       # @return [String] A line summarising the result totals of the spec run.
       def totals_line
-        summary = Formatters::Helpers.pluralize(example_count, "example")
-        summary << ", " << Formatters::Helpers.pluralize(failure_count, "failure")
-        summary << ", #{pending_count} pending" if pending_count > 0
+        summary = Formatters::Helpers.pluralize(example_count, "example") +
+          ", " + Formatters::Helpers.pluralize(failure_count, "failure")
+        summary += ", #{pending_count} pending" if pending_count > 0
+        if errors_outside_of_examples_count > 0
+          summary += (
+            ", " +
+            Formatters::Helpers.pluralize(errors_outside_of_examples_count, "error") +
+            " occurred outside of examples"
+          )
+        end
         summary
       end
 
@@ -391,8 +342,8 @@ module RSpec::Core
       # @param colorizer [#wrap] An object which supports wrapping text with
       #                          specific colors.
       # @return [String] A colorized results line.
-      def colorized_totals_line(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
-        if failure_count > 0
+      def colorized_totals_line(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
+        if failure_count > 0 || errors_outside_of_examples_count > 0
           colorizer.wrap(totals_line, RSpec.configuration.failure_color)
         elsif pending_count > 0
           colorizer.wrap(totals_line, RSpec.configuration.pending_color)
@@ -408,50 +359,81 @@ module RSpec::Core
       # @param colorizer [#wrap] An object which supports wrapping text with
       #                          specific colors.
       # @return [String] A colorized summary line.
-      def colorized_rerun_commands(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
+      def colorized_rerun_commands(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
         "\nFailed examples:\n\n" +
         failed_examples.map do |example|
-          colorizer.wrap("rspec #{example.location}",     RSpec.configuration.failure_color) + " " +
-          colorizer.wrap("# #{example.full_description}", RSpec.configuration.detail_color)
+          colorizer.wrap("rspec #{rerun_argument_for(example)}", RSpec.configuration.failure_color) + " " +
+          colorizer.wrap("# #{example.full_description}",   RSpec.configuration.detail_color)
         end.join("\n")
       end
 
-      # @return [String] a formatted version of the time it took to run the suite
+      # @return [String] a formatted version of the time it took to run the
+      #   suite
       def formatted_duration
         Formatters::Helpers.format_duration(duration)
       end
 
-      # @return [String] a formatted version of the time it took to boot RSpec and
-      #   load the spec files
+      # @return [String] a formatted version of the time it took to boot RSpec
+      #   and load the spec files
       def formatted_load_time
         Formatters::Helpers.format_duration(load_time)
       end
 
       # @return [String] The summary information fully formatted in the way that
       #   RSpec's built-in formatters emit.
-      def fully_formatted(colorizer = ::RSpec::Core::Formatters::ConsoleCodes)
+      def fully_formatted(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
         formatted = "\nFinished in #{formatted_duration} " \
                     "(files took #{formatted_load_time} to load)\n" \
                     "#{colorized_totals_line(colorizer)}\n"
 
         unless failed_examples.empty?
-          formatted << colorized_rerun_commands(colorizer) << "\n"
+          formatted += (colorized_rerun_commands(colorizer) + "\n")
         end
 
         formatted
       end
+
+    private
+
+      include RSpec::Core::ShellEscape
+
+      def rerun_argument_for(example)
+        location = example.location_rerun_argument
+        return location unless duplicate_rerun_locations.include?(location)
+        conditionally_quote(example.id)
+      end
+
+      def duplicate_rerun_locations
+        @duplicate_rerun_locations ||= begin
+          locations = RSpec.world.all_examples.map(&:location_rerun_argument)
+
+          Set.new.tap do |s|
+            locations.group_by { |l| l }.each do |l, ls|
+              s << l if ls.count > 1
+            end
+          end
+        end
+      end
     end
 
-    # The `ProfileNotification` holds information about the results of running
-    # a test suite when profiling is enabled. It is used by formatters to provide
+    # The `ProfileNotification` holds information about the results of running a
+    # test suite when profiling is enabled. It is used by formatters to provide
     # information at the end of the test run for profiling information.
     #
     # @attr duration [Float] the time taken (in seconds) to run the suite
-    # @attr examples [Array(RSpec::Core::Example)] the examples run
+    # @attr examples [Array<RSpec::Core::Example>] the examples run
     # @attr number_of_examples [Fixnum] the number of examples to profile
-    ProfileNotification = Struct.new(:duration, :examples, :number_of_examples) do
+    # @attr example_groups [Array<RSpec::Core::Profiler>] example groups run
+    class ProfileNotification
+      def initialize(duration, examples, number_of_examples, example_groups)
+        @duration = duration
+        @examples = examples
+        @number_of_examples = number_of_examples
+        @example_groups = example_groups
+      end
+      attr_reader :duration, :examples, :number_of_examples
 
-      # @return [Array(RSpec::Core::Example)] the slowest examples
+      # @return [Array<RSpec::Core::Example>] the slowest examples
       def slowest_examples
         @slowest_examples ||=
           examples.sort_by do |example|
@@ -476,7 +458,7 @@ module RSpec::Core
           end
       end
 
-      # @return [Array(RSpec::Core::Example)] the slowest example groups
+      # @return [Array<RSpec::Core::Example>] the slowest example groups
       def slowest_groups
         @slowest_groups ||= calculate_slowest_groups
       end
@@ -484,39 +466,30 @@ module RSpec::Core
     private
 
       def calculate_slowest_groups
-        example_groups = {}
-
-        examples.each do |example|
-          location = example.example_group.parent_groups.last.metadata[:location]
-
-          location_hash = example_groups[location] ||= Hash.new(0)
-          location_hash[:total_time]  += example.execution_result.run_time
-          location_hash[:count]       += 1
-          unless location_hash.has_key?(:description)
-            location_hash[:description] = example.example_group.top_level_description
-          end
-        end
-
         # stop if we've only one example group
-        return {} if example_groups.keys.length <= 1
+        return {} if @example_groups.keys.length <= 1
 
-        example_groups.each_value do |hash|
+        @example_groups.each_value do |hash|
           hash[:average] = hash[:total_time].to_f / hash[:count]
         end
 
-        example_groups.sort_by { |_, hash| -hash[:average] }.first(number_of_examples)
+        groups = @example_groups.sort_by { |_, hash| -hash[:average] }.first(number_of_examples)
+        groups.map { |group, data| [group.location, data] }
       end
     end
 
     # The `DeprecationNotification` is issued by the reporter when a deprecated
-    # part of RSpec is encountered. It represents information about the deprecated
-    # call site.
+    # part of RSpec is encountered. It represents information about the
+    # deprecated call site.
     #
     # @attr message [String] A custom message about the deprecation
-    # @attr deprecated [String] A custom message about the deprecation (alias of message)
+    # @attr deprecated [String] A custom message about the deprecation (alias of
+    #   message)
     # @attr replacement [String] An optional replacement for the deprecation
-    # @attr call_site [String] An optional call site from which the deprecation was issued
-    DeprecationNotification = Struct.new(:deprecated, :message, :replacement, :call_site) do
+    # @attr call_site [String] An optional call site from which the deprecation
+    #   was issued
+    DeprecationNotification = Struct.new(:deprecated, :message, :replacement, :call_site)
+    class DeprecationNotification
       private_class_method :new
 
       # @api
@@ -531,5 +504,18 @@ module RSpec::Core
     class NullNotification
     end
 
+    # `CustomNotification` is used when sending custom events to formatters /
+    # other registered listeners, it creates attributes based on supplied hash
+    # of options.
+    class CustomNotification < Struct
+      # @param options [Hash] A hash of method / value pairs to create on this notification
+      # @return [CustomNotification]
+      #
+      # Build a custom notification based on the supplied option key / values.
+      def self.for(options={})
+        return NullNotification if options.keys.empty?
+        new(*options.keys).new(*options.values)
+      end
+    end
   end
 end