inspec 1.0.0 → 1.35.1

data/lib/inspec/rspec_json_formatter.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 # author: Dominik Richter
 # author: Christoph Hartmann
+# author: John Kerry
 
 require 'rspec/core'
 require 'rspec/core/formatters/json_formatter'
@@ -51,7 +52,12 @@ class InspecRspecMiniJson < RSpec::Core::Formatters::JsonFormatter
       format_example(example).tap do |hash|
         e = example.exception
         next unless e
-        hash[:message] = e.message
+
+        if example.metadata[:sensitive]
+          hash[:message] = '*** sensitive output suppressed ***'
+        else
+          hash[:message] = exception_message(e)
+        end
 
         next if e.is_a? RSpec::Expectations::ExpectationNotMetError
         hash[:exception] = e.class.name
@@ -62,17 +68,26 @@ class InspecRspecMiniJson < RSpec::Core::Formatters::JsonFormatter
 
   private
 
-  def format_example(example)
-    if example.metadata[:description_args].length == 0
-      code_description = example.metadata[:full_description]
+  def exception_message(exception)
+    if exception.is_a?(RSpec::Core::MultipleExceptionError)
+      exception.all_exceptions.map(&:message).uniq.join("\n\n")
     else
+      exception.message
+    end
+  end
+
+  def format_example(example)
+    if !example.metadata[:description_args].empty? && example.metadata[:skip]
       # For skipped profiles, rspec returns in full_description the skip_message as well. We don't want
       # to mix the two, so we pick the full_description from the example.metadata[:example_group] hash.
       code_description = example.metadata[:example_group][:description]
+    else
+      code_description = example.metadata[:full_description]
     end
 
     res = {
       id: example.metadata[:id],
+      profile_id: example.metadata[:profile_id],
       status: example.execution_result.status.to_s,
       code_desc: code_description,
     }
@@ -92,13 +107,12 @@ class InspecRspecMiniJson < RSpec::Core::Formatters::JsonFormatter
 end
 
 class InspecRspecJson < InspecRspecMiniJson # rubocop:disable Metrics/ClassLength
-  RSpec::Core::Formatters.register self, :start, :stop, :dump_summary
+  RSpec::Core::Formatters.register self, :stop, :dump_summary
   attr_writer :backend
 
   def initialize(*args)
     super(*args)
     @profiles = []
-    # Will be valid after "start" state is reached.
     @profiles_info = nil
     @backend = nil
   end
@@ -108,37 +122,34 @@ class InspecRspecJson < InspecRspecMiniJson # rubocop:disable Metrics/ClassLengt
     @profiles.push(profile)
   end
 
-  # Called after all examples have been collected but before rspec
-  # test execution has begun.
-  def start(_notification)
-    # Note that the default profile may have no name - therefore
-    # the hash may have a valid nil => entry.
-    @profiles_info = @profiles.map(&:info!).map(&:dup)
-  end
-
-  def dump_one_example(example, control)
-    control[:results] ||= []
-    example.delete(:id)
-    example.delete(:profile_id)
-    control[:results].push(example)
-  end
-
   def stop(notification)
     super(notification)
-    examples = @output_hash.delete(:controls)
-    missing = []
 
-    examples.each do |example|
-      control = example2control(example, @profiles_info)
-      next missing.push(example) if control.nil?
-      dump_one_example(example, control)
+    @output_hash[:other_checks] = examples_without_controls
+    @output_hash[:profiles] = profiles_info
+    @output_hash[:platform] = {
+      name: os(:name),
+      release: os(:release),
+    }
+
+    examples_with_controls.each do |example|
+      control = example2control(example)
+      move_example_into_control(example, control)
     end
+  end
 
-    @output_hash[:profiles] = @profiles_info
-    @output_hash[:other_checks] = missing
+  private
+
+  def os(field)
+    return nil if @backend.nil?
+    @backend.os.params[field]
+  end
+
+  def all_unique_controls
+    Array(@all_controls).uniq
   end
 
-  def controls_summary
+  def profile_summary
     failed = 0
     skipped = 0
     passed = 0
@@ -146,7 +157,7 @@ class InspecRspecJson < InspecRspecMiniJson # rubocop:disable Metrics/ClassLengt
     major = 0
     minor = 0
 
-    @control_tests.each do |control|
+    all_unique_controls.each do |control|
       next if control[:id].start_with? '(generated from '
       next unless control[:results]
       if control[:results].any? { |r| r[:status] == 'failed' }
@@ -184,8 +195,7 @@ class InspecRspecJson < InspecRspecMiniJson # rubocop:disable Metrics/ClassLengt
     skipped = 0
     passed = 0
 
-    all_tests = @anonymous_tests + @control_tests
-    all_tests.each do |control|
+    all_unique_controls.each do |control|
       next unless control[:results]
       control[:results].each do |result|
         if result[:status] == 'failed'
@@ -201,37 +211,62 @@ class InspecRspecJson < InspecRspecMiniJson # rubocop:disable Metrics/ClassLengt
     { 'total' => total, 'failed' => failed, 'skipped' => skipped, 'passed' => passed }
   end
 
-  private
+  def examples
+    @output_hash[:controls]
+  end
 
-  #
-  # TODO(ssd+vj): We should probably solve this by either ensuring the example has
-  # the profile_id of the top level profile when it is included as a dependency, or
-  # by registrying all dependent profiles with the formatter. The we could remove
-  # this heuristic matching.
-  #
-  def example2profile(example, profiles)
-    profiles.find { |p| profile_contains_example?(p, example) }
+  def examples_without_controls
+    examples.find_all { |example| example2control(example).nil? }
   end
 
-  def profile_contains_example?(profile, example)
-    # Heuristic for finding the profile an example came from:
-    # Case 1: The profile_id on the example matches the name of the profile
-    # Case 2: The profile contains a control that matches the id of the example
-    if profile[:name] == example[:profile_id]
-      true
-    elsif profile[:controls] && profile[:controls].any? { |x| x[:id] == example[:id] }
-      true
-    else
-      false
-    end
+  def examples_with_controls
+    (examples - examples_without_controls)
+  end
+
+  def profiles_info
+    @profiles_info ||= @profiles.map(&:info!).map(&:dup)
   end
 
-  def example2control(example, profiles)
-    profile = example2profile(example, profiles)
+  def example2control(example)
+    profile = profile_from_example(example)
     return nil unless profile && profile[:controls]
     profile[:controls].find { |x| x[:id] == example[:id] }
   end
 
+  def profile_from_example(example)
+    profiles_info.find { |p| profile_contains_example?(p, example) }
+  end
+
+  def profile_contains_example?(profile, example)
+    profile_name = profile[:name]
+    example_profile_id = example[:profile_id]
+
+    # if either the profile name is nil or the profile in the given example
+    # is nil, assume the profile doesn't contain the example and default
+    # to creating a new profile. Otherwise, for profiles that have no
+    # metadata, this may incorrectly match a profile that does not contain
+    # this example, leading to Ruby exceptions.
+    return false if profile_name.nil? || example_profile_id.nil?
+
+    # The correct profile is one where the name of the profile, and the profile
+    # name in the example match. Additionally, the list of controls in the
+    # profile must contain the example in question (which we match by ID).
+    #
+    # While the profile name match is usually good enough, we must also match by
+    # the control ID in the case where an InSpec runner has multiple profiles of
+    # the same name (i.e. when Test Kitchen is running concurrently using a
+    # single test suite that uses the Flat source reader, in which case InSpec
+    # creates a fake profile with a name like "tests from /path/to/tests")
+    profile_name == example_profile_id && profile[:controls].any? { |control| control[:id] == example[:id] }
+  end
+
+  def move_example_into_control(example, control)
+    control[:results] ||= []
+    example.delete(:id)
+    example.delete(:profile_id)
+    control[:results].push(example)
+  end
+
   def format_example(example)
     super(example).tap do |res|
       res[:run_time]   = example.execution_result.run_time
@@ -243,298 +278,650 @@ end
 class InspecRspecCli < InspecRspecJson # rubocop:disable Metrics/ClassLength
   RSpec::Core::Formatters.register self, :close
 
-  STATUS_TYPES = {
-    'unknown'  => -3,
-    'passed'   => -2,
-    'skipped'  => -1,
-    'minor'    => 1,
-    'major'    => 2,
-    'failed'   => 2.5,
-    'critical' => 3,
-  }.freeze
-
-  COLORS = {
-    'critical' => "\033[31;1m",
-    'major'    => "\033[31m",
-    'minor'    => "\033[33m",
-    'failed'   => "\033[31m",
-    'passed'   => "\033[32m",
-    'skipped'  => "\033[37m",
-    'reset'    => "\033[0m",
-  }.freeze
-
-  INDICATORS = {
-    'critical' => '  ✖  ',
-    'major'    => '  ✖  ',
-    'minor'    => '  ✖  ',
-    'failed'   => '  ✖  ',
-    'skipped'  => '  ○  ',
-    'passed'   => '  ✔  ',
-    'unknown'  => '  ?  ',
-    'empty'    => '     ',
-    'small'    => '   ',
-  }.freeze
+  case RUBY_PLATFORM
+  when /windows|mswin|msys|mingw|cygwin/
+
+    # Most currently available Windows terminals have poor support
+    # for ANSI extended colors
+    COLORS = {
+      'critical' => "\033[0;1;31m",
+      'major'    => "\033[0;1;31m",
+      'minor'    => "\033[0;36m",
+      'failed'   => "\033[0;1;31m",
+      'passed'   => "\033[0;1;32m",
+      'skipped'  => "\033[0;37m",
+      'reset'    => "\033[0m",
+    }.freeze
+
+    # Most currently available Windows terminals have poor support
+    # for UTF-8 characters so use these boring indicators
+    INDICATORS = {
+      'critical' => '  [CRIT]  ',
+      'major'    => '  [MAJR]  ',
+      'minor'    => '  [MINR]  ',
+      'failed'   => '  [FAIL]  ',
+      'skipped'  => '  [SKIP]  ',
+      'passed'   => '  [PASS]  ',
+      'unknown'  => '  [UNKN]  ',
+      'empty'    => '     ',
+      'small'    => '   ',
+    }.freeze
+  else
+    # Extended colors for everyone else
+    COLORS = {
+      'critical' => "\033[38;5;9m",
+      'major'    => "\033[38;5;208m",
+      'minor'    => "\033[0;36m",
+      'failed'   => "\033[38;5;9m",
+      'passed'   => "\033[38;5;41m",
+      'skipped'  => "\033[38;5;247m",
+      'reset'    => "\033[0m",
+    }.freeze
+
+    # Groovy UTF-8 characters for everyone else...
+    # ...even though they probably only work on Mac
+    INDICATORS = {
+      'critical' => '  ×  ',
+      'major'    => '  ∅  ',
+      'minor'    => '  ⊚  ',
+      'failed'   => '  ×  ',
+      'skipped'  => '  ↺  ',
+      'passed'   => '  ✔  ',
+      'unknown'  => '  ?  ',
+      'empty'    => '     ',
+      'small'    => '   ',
+    }.freeze
+  end
 
   MULTI_TEST_CONTROL_SUMMARY_MAX_LEN = 60
 
   def initialize(*args)
-    @colors = COLORS
-    @indicators = INDICATORS
-
-    @format = '%color%indicator%id%summary'
     @current_control = nil
-    @current_profile = nil
-    @missing_controls = []
-    @anonymous_tests = []
-    @control_tests = []
+    @all_controls = []
+    @profile_printed = false
     super(*args)
   end
 
-  def close(_notification) # rubocop:disable Metrics/AbcSize
-    flush_current_control
-    output.puts('') unless @current_control.nil?
-    print_tests
-    output.puts('')
+  #
+  # This method is called through the RSpec Formatter interface for every
+  # example found in the test suite.
+  #
+  # Within #format_example we are getting an example and:
+  #    * if this is an example, within a control, within a profile then we want
+  #      to display the profile header, display the control, and then display
+  #      the example.
+  #    * if this is another example, within the same control, within the same
+  #      profile we want to display the example.
+  #    * if this is an example that does not map to a control (anonymous) then
+  #      we want to store it for later to displayed at the end of a profile.
+  #
+  def format_example(example)
+    example_data = super(example)
+    control = create_or_find_control(example_data)
 
-    @profiles_info.each do |profile|
-      next if profile[:already_printed]
-      @current_profile = profile
-      next unless print_current_profile
-      print_line(
-        color: '', indicator: @indicators['empty'], id: '', profile: '',
-        summary: 'No tests executed.'
-      ) if @current_control.nil?
-      output.puts('')
+    # If we are switching to a new control then we want to print the control
+    # we were previously collecting examples unless the last control is
+    # anonymous (no control). Anonymous controls and their examples are handled
+    # later on the profile change.
+
+    if switching_to_new_control?(control)
+      print_last_control_with_examples unless last_control_is_anonymous?
     end
 
-    controls_res = controls_summary
-    tests_res = tests_summary
+    store_last_control(control)
+
+    # Each profile may have zero or more anonymous examples. These are examples
+    # that defined in a profile but outside of a control. They may be defined
+    # at the start, in-between, or end of list of examples. To display them
+    # at the very end of a profile, which means we have to wait for the profile
+    # to change to know we are done with a profile.
+
+    if switching_to_new_profile?(control.profile)
+      output.puts ''
+      print_anonymous_examples_associated_with_last_profile
+      clear_anonymous_examples_associated_with_last_profile
+    end
+
+    print_profile(control.profile)
+    store_last_profile(control.profile)
+
+    # The anonymous controls should be added to a hash that we will display
+    # when we are done examining all the examples within this profile.
 
-    s = format('Profile Summary: %s%d successful%s, %s%d failures%s, %s%d skipped%s',
-               COLORS['passed'], controls_res['passed'], COLORS['reset'],
-               COLORS['failed'], controls_res['failed']['total'], COLORS['reset'],
-               COLORS['skipped'], controls_res['skipped'], COLORS['reset'])
-    output.puts(s) if controls_res['total'] > 0
+    if control.anonymous?
+      add_anonymous_example_within_this_profile(control.as_hash)
+    end
+
+    @all_controls.push(control.as_hash)
+    example_data
+  end
 
-    s = format('Test Summary: %s%d successful%s, %s%d failures%s, %s%d skipped%s',
-               COLORS['passed'], tests_res['passed'], COLORS['reset'],
-               COLORS['failed'], tests_res['failed'], COLORS['reset'],
-               COLORS['skipped'], tests_res['skipped'], COLORS['reset'])
-    output.puts(s) if !@anonymous_tests.empty? || @current_control.nil?
+  #
+  # This is the last method is invoked through the formatter interface.
+  # Because the profile
+  # we may have some remaining anonymous examples so we want to display them
+  # as well as a summary of the profile and test stats.
+  #
+  def close(_notification)
+    # when the profile has no controls or examples it will not have been printed.
+    # then we want to ensure we print all the profiles
+    print_last_control_with_examples unless last_control_is_anonymous?
+    output.puts ''
+    print_anonymous_examples_associated_with_last_profile
+    print_profiles_without_examples
+    print_profile_summary
+    print_tests_summary
   end
 
   private
 
-  def status_type(data, control)
-    status = data[:status]
-    return status if status != 'failed' || control[:impact].nil?
-    if control[:impact] >= 0.7
-      'critical'
-    elsif control[:impact] >= 0.4
-      'major'
+  #
+  # With the example we can find the profile associated with it and if there
+  # is already a control defined. If there is one then we will use that data
+  # to build our control object. If there isn't we simply create a new hash of
+  # controld data that will be populated from the examples that are found.
+  #
+  # @return [Control] A new control or one found associated with the example.
+  #
+  def create_or_find_control(example)
+    profile = profile_from_example(example)
+
+    control_data = {}
+
+    if profile && profile[:controls]
+      control_data = profile[:controls].find { |ctrl| ctrl[:id] == example[:id] }
+    end
+
+    control = Control.new(control_data, profile)
+    control.add_example(example)
+
+    control
+  end
+
+  #
+  # If there is already a control we have have seen before and it is different
+  # than the new control then we are indeed switching controls.
+  #
+  def switching_to_new_control?(control)
+    @last_control && @last_control != control
+  end
+
+  def store_last_control(control)
+    @last_control = control
+  end
+
+  def print_last_control_with_examples
+    if @last_control
+      print_control(@last_control)
+      @last_control.examples.each { |example| print_result(example) }
+    end
+  end
+
+  def last_control_is_anonymous?
+    @last_control && @last_control.anonymous?
+  end
+
+  #
+  # If there is a profile we have seen before and it is different than the
+  # new profile then we are indeed switching profiles.
+  #
+  def switching_to_new_profile?(new_profile)
+    @last_profile && @last_profile != new_profile
+  end
+
+  #
+  # Print all the anonymous examples that have been found for this profile
+  #
+  def print_anonymous_examples_associated_with_last_profile
+    Array(anonymous_examples_within_this_profile).uniq.each do |control|
+      print_anonymous_control(control)
+    end
+    output.puts '' unless Array(anonymous_examples_within_this_profile).empty?
+  end
+
+  #
+  # As we process examples we need an accumulator that will allow us to store
+  # all the examples that do not have a named control associated with them.
+  #
+  def anonymous_examples_within_this_profile
+    @anonymous_examples_within_this_profile ||= []
+  end
+
+  #
+  # Remove all controls from the anonymous examples that are tracked.
+  #
+  def clear_anonymous_examples_associated_with_last_profile
+    @anonymous_examples_within_this_profile = []
+  end
+
+  #
+  # Append a new control to the anonymous examples
+  #
+  def add_anonymous_example_within_this_profile(control)
+    anonymous_examples_within_this_profile.push(control)
+  end
+
+  def store_last_profile(new_profile)
+    @last_profile = new_profile
+  end
+
+  #
+  # Print the profile
+  #
+  #   * For anonymous profiles, where are generated for examples and controls
+  #     defined outside of a profile, simply display the target information
+  #   * For profiles without a title use the name (or 'unknown'), version,
+  #     and target information.
+  #   * For all other profiles display the title with name (or 'unknown'),
+  #     version, and target information.
+  #
+  def print_profile(profile)
+    return if profile.nil? || profile[:already_printed]
+    output.puts ''
+
+    if profile[:name].nil?
+      print_target
+      profile[:already_printed] = true
+      return
+    end
+
+    if profile[:title].nil?
+      output.puts "Profile: #{profile[:name] || 'unknown'}"
     else
-      'minor'
-    end
-  end
-
-  def current_control_infos
-    summary_status = STATUS_TYPES['unknown']
-    skips = []
-    fails = []
-    passes = []
-    @current_control[:results].each do |r|
-      i = STATUS_TYPES[r[:status_type]]
-      summary_status = i if i > summary_status
-      fails.push(r) if i > 0
-      passes.push(r) if i == STATUS_TYPES['passed']
-      skips.push(r) if i == STATUS_TYPES['skipped']
-    end
-    [fails, skips, passes, STATUS_TYPES.key(summary_status)]
-  end
-
-  def current_control_title
-    title = @current_control[:title]
-    res = @current_control[:results]
-    if title
-      title
-    elsif res.length == 1
-      # If it's an anonymous control, just go with the only description
-      # available for the underlying test.
-      res[0][:code_desc].to_s
-    elsif res.length == 0
-      # Empty control block - if it's anonymous, there's nothing we can do.
-      # Is this case even possible?
-      'Empty anonymous control'
+      output.puts "Profile: #{profile[:title]} (#{profile[:name] || 'unknown'})"
+    end
+
+    output.puts 'Version: ' + (profile[:version] || '(not specified)')
+    print_target
+    profile[:already_printed] = true
+  end
+
+  def print_profiles_without_examples
+    profiles_info.reject { |p| p[:already_printed] }.each do |profile|
+      print_profile(profile)
+      print_line(
+        color: '', indicator: INDICATORS['empty'], id: '', profile: '',
+        summary: 'No tests executed.'
+      )
+      output.puts ''
+    end
+  end
+
+  #
+  # This target information displays which system that came under test
+  #
+  def print_target
+    return if @backend.nil?
+    connection = @backend.backend
+    return unless connection.respond_to?(:uri)
+    output.puts('Target:  ' + connection.uri + "\n\n")
+  end
+
+  #
+  # We want to print the details about the control
+  #
+  def print_control(control)
+    print_line(
+      color:      control.summary_indicator,
+      indicator:  INDICATORS[control.summary_indicator] || INDICATORS['unknown'],
+      summary:    format_lines(control.summary, INDICATORS['empty']),
+      id:         "#{control.id}: ",
+      profile:    control.profile_id,
+    )
+  end
+
+  def print_result(result)
+    test_status = result[:status_type]
+    indicator = INDICATORS[result[:status]]
+    indicator = INDICATORS['empty'] if indicator.nil?
+    if result[:message]
+      msg = result[:code_desc] + "\n" + result[:message]
     else
-      # Multiple tests - but no title. Do our best and generate some form of
-      # identifier or label or name.
-      title = (res.map { |r| r[:code_desc] }).join('; ')
-      max_len = MULTI_TEST_CONTROL_SUMMARY_MAX_LEN
-      title = title[0..(max_len-1)] + '...' if title.length > max_len
-      title
-    end
-  end
-
-  def current_control_summary(fails, skips)
-    title = current_control_title
-    res = @current_control[:results]
-    suffix =
-      if res.length == 1
-        # Single test - be nice and just print the exception message if the test
-        # failed. No need to say "1 failed".
-        res[0][:message].to_s
+      msg = result[:skip_message] || result[:code_desc]
+    end
+    print_line(
+      color:      test_status,
+      indicator:  INDICATORS['small'] + indicator,
+      summary:    format_lines(msg, INDICATORS['empty']),
+      id: nil, profile: nil
+    )
+  end
+
+  def print_anonymous_control(control)
+    control_result = control[:results]
+    title = control_result[0][:code_desc].split[0..1].join(' ')
+    puts '  ' + title
+    # iterate over all describe blocks in anonoymous control block
+    control_result.each do |test|
+      control_id = ''
+      # display exceptions
+      unless test[:exception].nil?
+        test_result = test[:message]
       else
-        [
-          (fails.length > 0) ? "#{fails.length} failed" : nil,
-          (skips.length > 0) ? "#{skips.length} skipped" : nil,
-        ].compact.join(' ')
+        # determine title
+        test_result = test[:skip_message] || test[:code_desc].split[2..-1].join(' ')
+        # show error message
+        test_result += "\n" + test[:message] unless test[:message].nil?
       end
-    if suffix == ''
-      title
-    else
-      title + ' (' + suffix + ')'
+      status_indicator = test[:status_type]
+      print_line(
+        color:      status_indicator,
+        indicator:  INDICATORS['small'] + INDICATORS[status_indicator] || INDICATORS['unknown'],
+        summary:    format_lines(test_result, INDICATORS['empty']),
+        id:         control_id,
+        profile:    control[:profile_id],
+      )
     end
   end
 
+  def print_profile_summary
+    summary = profile_summary
+    return unless summary['total'] > 0
+
+    success_str = summary['passed'] == 1 ? '1 successful control' : "#{summary['passed']} successful controls"
+    failed_str  = summary['failed']['total'] == 1 ? '1 control failure' : "#{summary['failed']['total']} control failures"
+    skipped_str = summary['skipped'] == 1 ? '1 control skipped' : "#{summary['skipped']} controls skipped"
+
+    success_color = summary['passed'] > 0 ? 'passed' : 'no_color'
+    failed_color = summary['failed']['total'] > 0 ? 'failed' : 'no_color'
+    skipped_color = summary['skipped'] > 0 ? 'skipped' : 'no_color'
+
+    s = format('Profile Summary: %s, %s, %s',
+               format_with_color(success_color, success_str),
+               format_with_color(failed_color, failed_str),
+               format_with_color(skipped_color, skipped_str),
+              )
+    output.puts(s) if summary['total'] > 0
+  end
+
+  def print_tests_summary
+    summary = tests_summary
+
+    failed_str = summary['failed'] == 1 ? '1 failure' : "#{summary['failed']} failures"
+
+    success_color = summary['passed'] > 0 ? 'passed' : 'no_color'
+    failed_color = summary['failed'] > 0 ? 'failed' : 'no_color'
+    skipped_color = summary['skipped'] > 0 ? 'skipped' : 'no_color'
+
+    s = format('Test Summary: %s, %s, %s',
+               format_with_color(success_color, "#{summary['passed']} successful"),
+               format_with_color(failed_color, failed_str),
+               format_with_color(skipped_color, "#{summary['skipped']} skipped"),
+              )
+
+    output.puts(s)
+  end
+
+  # Formats the line (called from print_line)
   def format_line(fields)
-    @format.gsub(/%\w+/) do |x|
+    format = '%indicator%id%summary'
+    format.gsub(/%\w+/) do |x|
       term = x[1..-1]
       fields.key?(term.to_sym) ? fields[term.to_sym].to_s : x
-    end + @colors['reset']
+    end
   end
 
+  # Prints line; used to print results
   def print_line(fields)
-    output.puts(format_line(fields))
+    output.puts(format_with_color(fields[:color], format_line(fields)))
   end
 
+  # Helps formatting summary lines (called from within print_line arguments)
   def format_lines(lines, indentation)
     lines.gsub(/\n/, "\n" + indentation)
   end
 
-  def print_results(all)
-    all.each do |x|
-      test_status = x[:status_type]
-      test_color = @colors[test_status]
-      indicator = @indicators[x[:status]]
-      indicator = @indicators['empty'] if indicator.nil?
-      if x[:message]
-        msg = x[:code_desc] + "\n" + x[:message]
+  def format_with_color(color_name, text)
+    return text unless RSpec.configuration.color
+    return text unless COLORS.key?(color_name)
+
+    "#{COLORS[color_name]}#{text}#{COLORS['reset']}"
+  end
+
+  #
+  # This class wraps a control hash object to provide a useful inteface for
+  # maintaining the associated profile, ids, results, title, etc.
+  #
+  class Control # rubocop:disable Metrics/ClassLength
+    include Comparable
+
+    STATUS_TYPES = {
+      'unknown'  => -3,
+      'passed'   => -2,
+      'skipped'  => -1,
+      'minor'    => 1,
+      'major'    => 2,
+      'failed'   => 2.5,
+      'critical' => 3,
+    }.freeze
+
+    def initialize(control, profile)
+      @control = control
+      @profile = profile
+      summary_calculation_is_needed
+    end
+
+    attr_reader :control, :profile
+
+    alias as_hash control
+
+    def id
+      control[:id]
+    end
+
+    def anonymous?
+      control[:id].to_s.start_with? '(generated from '
+    end
+
+    def profile_id
+      control[:profile_id]
+    end
+
+    def examples
+      control[:results]
+    end
+
+    def summary_indicator
+      calculate_summary! if summary_calculation_needed?
+      STATUS_TYPES.key(@summary_status)
+    end
+
+    def add_example(example)
+      control[:id] = example[:id]
+      control[:profile_id] = example[:profile_id]
+
+      example[:status_type] = status_type(example)
+      example.delete(:id)
+      example.delete(:profile_id)
+
+      control[:results] ||= []
+      control[:results].push(example)
+      summary_calculation_is_needed
+    end
+
+    # Determine title for control given current_control.
+    # Called from current_control_summary.
+    def title
+      title = control[:title]
+      if title
+        title
+      elsif examples.length == 1
+        # If it's an anonymous control, just go with the only description
+        # available for the underlying test.
+        examples[0][:code_desc].to_s
+      elsif examples.empty?
+        # Empty control block - if it's anonymous, there's nothing we can do.
+        # Is this case even possible?
+        'Empty anonymous control'
       else
-        msg = x[:skip_message] || x[:code_desc]
+        # Multiple tests - but no title. Do our best and generate some form of
+        # identifier or label or name.
+        title = (examples.map { |example| example[:code_desc] }).join('; ')
+        max_len = MULTI_TEST_CONTROL_SUMMARY_MAX_LEN
+        title = title[0..(max_len-1)] + '...' if title.length > max_len
+        title
       end
-      print_line(
-        color:      test_color,
-        indicator:  @indicators['small'] + indicator,
-        summary:    format_lines(msg, @indicators['empty']),
-        id: nil, profile: nil
-      )
     end
-  end
 
-  def print_tests # rubocop:disable Metrics/AbcSize
-    @anonymous_tests.each do |control|
-      control_result = control[:results]
-      title = control_result[0][:code_desc].split[0..1].join(' ')
-      puts '  ' + title
-      # iterate over all describe blocks in anonoymous control block
-      control_result.each do |test|
-        control_id = ''
-        # display exceptions
-        unless test[:exception].nil?
-          test_result = test[:message]
+    # Return summary of the control which is usually a title with fails and skips
+    def summary
+      calculate_summary! if summary_calculation_needed?
+      suffix =
+        if examples.length == 1
+          # Single test - be nice and just print the exception message if the test
+          # failed. No need to say "1 failed".
+          examples[0][:message].to_s
         else
-          # determine title
-          test_result = test[:skip_message] || test[:code_desc].split[2..-1].join(' ')
-          # show error message
-          test_result += "\n" + test[:message] unless test[:message].nil?
+          [
+            !fails.empty? ? "#{fails.uniq.length} failed" : nil,
+            !skips.empty? ? "#{skips.uniq.length} skipped" : nil,
+          ].compact.join(' ')
         end
-        status_indicator = test[:status_type]
-        print_line(
-          color:      @colors[status_indicator] || '',
-          indicator:  @indicators['small'] + @indicators[status_indicator] || @indicators['unknown'],
-          summary:    format_lines(test_result, @indicators['empty']),
-          id:         control_id,
-          profile:    control[:profile_id],
-        )
+
+      suffix == '' ? title : title + ' (' + suffix + ')'
+    end
+
+    # We are interested in comparing controls against other controls. It is
+    # important to compare their id values and the id values of their profiles.
+    # In the event that a control has the same id in a different profile we
+    # do not want them to be considered the same.
+    #
+    # Controls are never ordered so we don't care about the remaining
+    # implementation of the spaceship operator.
+    #
+    def <=>(other)
+      if id == other.id && profile_id == other.profile_id
+        0
+      else
+        -1
       end
     end
-  end
 
-  def flush_current_control
-    return if @current_control.nil?
+    private
 
-    prev_profile = @current_profile
-    @current_profile = @profiles_info.find { |i| i[:id] == @current_control[:profile_id] }
-    print_current_profile if prev_profile != @current_profile
+    attr_reader :summary_calculation_needed, :skips, :fails, :passes
 
-    fails, skips, passes, summary_indicator = current_control_infos
-    summary = current_control_summary(fails, skips)
+    alias summary_calculation_needed? summary_calculation_needed
 
-    control_id = @current_control[:id].to_s
-    control_id += ': '
-    if control_id.start_with? '(generated from '
-      @anonymous_tests.push(@current_control)
-    else
-      @control_tests.push(@current_control)
-      print_line(
-        color:      @colors[summary_indicator] || '',
-        indicator:  @indicators[summary_indicator] || @indicators['unknown'],
-        summary:    format_lines(summary, @indicators['empty']),
-        id:         control_id,
-        profile:    @current_control[:profile_id],
-      )
+    def summary_calculation_is_needed
+      @summary_calculation_needed = true
+    end
 
-      print_results(fails + skips + passes)
+    def summary_has_been_calculated
+      @summary_calculation_needed = false
     end
-  end
 
-  def print_target(before, after)
-    return if @backend.nil?
-    connection = @backend.backend
-    return unless connection.respond_to?(:uri)
-    output.puts(before + connection.uri + after)
-  end
+    def calculate_summary!
+      @summary_status = STATUS_TYPES['unknown']
+      @skips = []
+      @fails = []
+      @passes = []
+      examples.each { |example| update_summary(example) }
+      summary_has_been_calculated
+    end
 
-  def print_current_profile
-    profile = @current_profile
-    return false if profile.nil?
+    def update_summary(example)
+      example_status = STATUS_TYPES[example[:status_type]]
+      @summary_status = example_status if example_status > @summary_status
+      fails.push(example) if example_status > 0
+      passes.push(example) if example_status == STATUS_TYPES['passed']
+      skips.push(example) if example_status == STATUS_TYPES['skipped']
+    end
 
-    output.puts ''
-    profile[:already_printed] = true
-    if profile[:name].nil?
-      print_target('Target:  ', "\n\n")
-      return true
+    # Determines 'status_type' (critical, major, minor) of control given
+    # status (failed/passed/skipped) and impact value (0.0 - 1.0).
+    # Called from format_example, sets the 'status_type' for each 'example'
+    def status_type(example)
+      status = example[:status]
+      return status if status != 'failed' || control[:impact].nil?
+      if control[:impact] >= 0.7
+        'critical'
+      elsif control[:impact] >= 0.4
+        'major'
+      else
+        'minor'
+      end
     end
+  end
+end
 
-    if profile[:title].nil?
-      output.puts "Profile: #{profile[:name] || 'unknown'}"
-    else
-      output.puts "Profile: #{profile[:title]} (#{profile[:name] || 'unknown'})"
+class InspecRspecJUnit < InspecRspecJson
+  RSpec::Core::Formatters.register self, :close
+
+  #
+  # This is the last method is invoked through the formatter interface.
+  # Converts the junit formatter constructed output_hash into REXML generated
+  # XML and writes it to output.
+  #
+  def close(_notification)
+    require 'rexml/document'
+    xml_output = REXML::Document.new
+    xml_output.add(REXML::XMLDecl.new)
+
+    testsuites = REXML::Element.new('testsuites')
+    xml_output.add(testsuites)
+
+    @output_hash[:profiles].each do |profile|
+      testsuites.add(build_profile_xml(profile))
     end
 
-    output.puts 'Version: ' + (profile[:version] || 'unknown')
-    print_target('Target:  ', "\n")
-    output.puts
-    true
+    formatter = REXML::Formatters::Pretty.new
+    formatter.compact = true
+    output.puts formatter.write(xml_output.xml_decl, '')
+    output.puts formatter.write(xml_output.root, '')
   end
 
-  def format_example(example)
-    data = super(example)
-    control = example2control(data, @profiles_info) || {}
-    control[:id] = data[:id]
-    control[:profile_id] = data[:profile_id]
+  private
+
+  def build_profile_xml(profile)
+    profile_xml = REXML::Element.new('testsuite')
+    profile_xml.add_attribute('name', profile[:name])
+    profile_xml.add_attribute('tests', count_profile_tests(profile))
+    profile_xml.add_attribute('failed', count_profile_failed_tests(profile))
 
-    data[:status_type] = status_type(data, control)
-    dump_one_example(data, control)
+    profile[:controls].each do |control|
+      next if control[:results].nil?
 
-    @current_control ||= control
-    if control[:id].nil?
-      @missing_controls.push(data)
-    elsif @current_control[:id] != control[:id]
-      flush_current_control
-      @current_control = control
+      control[:results].each do |result|
+        profile_xml.add(build_result_xml(control, result))
+      end
     end
 
-    data
+    profile_xml
+  end
+
+  def build_result_xml(control, result)
+    result_xml = REXML::Element.new('testcase')
+    result_xml.add_attribute('name', result[:code_desc])
+    result_xml.add_attribute('class', control[:title].nil? ? 'Anonymous' : control[:id])
+    result_xml.add_attribute('time', result[:run_time])
+
+    if result[:status] == 'failed'
+      failure_element = REXML::Element.new('failure')
+      failure_element.add_attribute('message', result[:message])
+      result_xml.add(failure_element)
+    elsif result[:status] == 'skipped'
+      result_xml.add_element('skipped')
+    end
+
+    result_xml
+  end
+
+  def count_profile_tests(profile)
+    profile[:controls].reduce(0) { |acc, elem|
+      acc + (elem[:results].nil? ? 0 : elem[:results].count)
+    }
+  end
+
+  def count_profile_failed_tests(profile)
+    profile[:controls].reduce(0) { |acc, elem|
+      if elem[:results].nil?
+        acc
+      else
+        acc + elem[:results].reduce(0) { |fail_test_total, test_case|
+          test_case[:status] == 'failed' ? fail_test_total + 1 : fail_test_total
+        }
+      end
+    }
   end
 end