inspec 4.18.51 → 4.18.85

data/lib/inspec/formatters.rb

@@ -1,3 +0,0 @@
-require "inspec/formatters/base"
-require "inspec/formatters/json_rspec"
-require "inspec/formatters/show_progress"

data/lib/inspec/formatters/base.rb

@@ -1,269 +0,0 @@
-require "rspec/core"
-require "rspec/core/formatters/base_formatter"
-
-module Inspec::Formatters
-  class Base < RSpec::Core::Formatters::BaseFormatter
-    RSpec::Core::Formatters.register self, :close, :dump_summary, :stop
-
-    attr_accessor :backend, :run_data
-
-    def initialize(output)
-      super(output)
-
-      @run_data = {}
-      @profiles = []
-      @profiles_info = nil
-      @backend = nil
-    end
-
-    # RSpec Override: #dump_summary
-    #
-    # Supply run summary data, such as the InSpec version and the total duration.
-    def dump_summary(summary)
-      run_data[:version] = Inspec::VERSION
-      run_data[:statistics] = {
-        duration: summary.duration,
-        controls: statistics,
-      }
-    end
-
-    # RSpec Override: #stop
-    #
-    # Called at the end of a complete RSpec run.
-    # We use this to map tests to controls and flesh out the rest of the run_data
-    # hash to include details about the run, the platform, etc.
-    def stop(notification)
-      # This might be a bit confusing. The results are not actually organized
-      # by control. It is organized by test. So if a control has 3 tests, the
-      # output will have 3 control entries, each one with the same control id
-      # and different test results. An rspec example maps to an inspec test.
-      run_data[:controls] = notification.examples.map do |example|
-        format_example(example).tap do |hash|
-          e = example.exception
-          next unless e
-
-          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
-          hash[:backtrace] = e.backtrace
-        end
-      end
-
-      # include any tests that were run that were not part of a control
-      run_data[:other_checks] = examples_without_controls
-      examples_with_controls.each do |example|
-        control = example2control(example)
-        move_example_into_control(example, control)
-      end
-
-      # flesh out the profiles key with additional profile information
-      run_data[:profiles] = profiles_info
-
-      # add the platform information for this particular target
-      run_data[:platform] = {
-        name: platform(:name),
-        release: platform(:release),
-        target: backend_target,
-      }
-    end
-
-    # Add the current profile to the list of executed profiles.
-    # Called by the runner during example collection.
-    def add_profile(profile)
-      @profiles.push(profile)
-    end
-
-    # Return all the collected output to the caller
-    def results
-      run_data
-    end
-
-    private
-
-    def all_unique_controls
-      unique_controls = Set.new
-      run_data[:profiles].each do |profile|
-        profile[:controls].map { |control| unique_controls.add(control) }
-      end
-
-      unique_controls
-    end
-
-    def statistics
-      failed = 0
-      skipped = 0
-      passed = 0
-
-      all_unique_controls.each do |control|
-        next unless control[:results]
-
-        if control[:results].any? { |r| r[:status] == "failed" }
-          failed += 1
-        elsif control[:results].any? { |r| r[:status] == "skipped" }
-          skipped += 1
-        else
-          passed += 1
-        end
-      end
-
-      total = failed + passed + skipped
-
-      {
-        total: total,
-        passed: {
-          total: passed,
-        },
-        skipped: {
-          total: skipped,
-        },
-        failed: {
-          total: failed,
-        },
-      }
-    end
-
-    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
-
-    # RSpec Override: #format_example
-    #
-    # Called after test execution, this allows us to populate our own hash with data
-    # for this test that is necessary for the rest of our reports.
-    def format_example(example) # rubocop:disable Metrics/AbcSize
-      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,
-        run_time: example.execution_result.run_time,
-        start_time: example.execution_result.started_at.to_datetime.rfc3339.to_s,
-        resource_title: example.metadata[:described_class] || example.metadata[:example_group][:description],
-        expectation_message: format_expectation_message(example),
-        waiver_data: example.metadata[:waiver_data],
-      }
-
-      unless (pid = example.metadata[:profile_id]).nil?
-        res[:profile_id] = pid
-      end
-
-      if res[:status] == "pending"
-        res[:status] = "skipped"
-        res[:skip_message] = example.metadata[:description]
-        res[:resource] = example.metadata[:described_class].to_s
-      end
-
-      res
-    end
-
-    def format_expectation_message(example)
-      if (example.metadata[:example_group][:description_args].first == example.metadata[:example_group][:described_class]) ||
-          example.metadata[:example_group][:described_class].nil?
-        example.metadata[:description]
-      else
-        "#{example.metadata[:example_group][:description]} #{example.metadata[:description]}"
-      end
-    end
-
-    # This formatter runs for all reports and we cannot error on missing fields.
-    # Return nil if not found or Train error. If needed, we will raise an error inside
-    # the proper report.
-    def platform(field)
-      return nil if @backend.nil?
-
-      begin
-        @backend.platform[field]
-      rescue Train::Error => e
-        Inspec::Log.warn(e.message)
-        nil
-      end
-    end
-
-    def backend_target
-      return nil if @backend.nil?
-
-      connection = @backend.backend
-      connection.respond_to?(:uri) ? connection.uri : nil
-    end
-
-    def examples
-      run_data[:controls]
-    end
-
-    def examples_without_controls
-      examples.find_all { |example| example2control(example).nil? }
-    end
-
-    def examples_with_controls
-      examples.find_all { |example| !example2control(example).nil? }
-    end
-
-    def profiles_info
-      @profiles_info ||= @profiles.map(&:info!).map(&:dup)
-    end
-
-    def example2control(example)
-      profile = profile_from_example(example)
-      return nil unless 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)
-
-      # Waiver data, if available, is internally stored on a per-result
-      # (that is, per-describe-block) basis, because that is the only granularity
-      # available to us in the RSpec report data structure which we use as a vehicle.
-      control[:waiver_data] ||= example[:waiver_data] || {}
-    end
-  end
-end

data/lib/inspec/formatters/json_rspec.rb

@@ -1,20 +0,0 @@
-module Inspec::Formatters
-  class RspecJson < RSpec::Core::Formatters::JsonFormatter
-    RSpec::Core::Formatters.register self
-
-    private
-
-    # We are cheating and overriding a private method in RSpec's core JsonFormatter.
-    # This is to avoid having to repeat this id functionality in both dump_summary
-    # and dump_profile (both of which call format_example).
-    # See https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/formatters/json_formatter.rb
-    #
-    # rspec's example id here corresponds to an inspec test's control name -
-    # either explicitly specified or auto-generated by rspec itself.
-    def format_example(example)
-      res = super(example)
-      res[:id] = example.metadata[:id]
-      res
-    end
-  end
-end

data/lib/inspec/formatters/show_progress.rb

@@ -1,12 +0,0 @@
-module Inspec::Formatters
-  class ShowProgress < RSpec::Core::Formatters::ProgressFormatter
-    RSpec::Core::Formatters.register self
-
-    # remove summary output from progress
-    %w{dump_summary dump_failures dump_pending message seed start_dump}.each do |m|
-      define_method(m) do |*args|
-        # override
-      end
-    end
-  end
-end

data/lib/inspec/globals.rb

@@ -1,9 +0,0 @@
-module Inspec
-  def self.config_dir
-    ENV["INSPEC_CONFIG_DIR"] ? ENV["INSPEC_CONFIG_DIR"] : File.join(Dir.home, ".inspec")
-  end
-
-  def self.src_root
-    File.expand_path(File.join(__FILE__, "..", "..", ".."))
-  end
-end

data/lib/inspec/impact.rb

@@ -1,36 +0,0 @@
-require "inspec/errors"
-
-# Impact scores based off CVSS 3.0
-module Inspec::Impact
-  IMPACT_SCORES = {
-    "none" => 0.0,
-    "low" => 0.1,
-    "medium" => 0.4,
-    "high" => 0.7,
-    "critical" => 0.9,
-  }.freeze
-
-  def self.impact_from_string(value)
-    # return if its a number
-    return value if is_number?(value)
-    raise Inspec::ImpactError, "'#{value}' is not a valid impact name. Valid impact names: none, low, medium, high, critical." unless IMPACT_SCORES.key?(value.downcase)
-
-    IMPACT_SCORES[value]
-  end
-
-  def self.is_number?(value)
-    Float(value)
-    true
-  rescue
-    false
-  end
-
-  def self.string_from_impact(value)
-    value = value.to_f
-    raise Inspec::ImpactError, "'#{value}' is not a valid impact score. Valid impact scores: [0.0 - 1.0]." if value < 0 || value > 1
-
-    IMPACT_SCORES.reverse_each do |name, impact|
-      return name if value >= impact
-    end
-  end
-end

data/lib/inspec/input.rb

@@ -1,421 +0,0 @@
-require "inspec/utils/deprecation"
-
-# For backwards compatibility during the rename (see #3802),
-# maintain the Inspec::Attribute namespace for people checking for
-# Inspec::Attribute::DEFAULT_ATTRIBUTE
-module Inspec
-  class Attribute
-    # This only exists to create the Inspec::Attribute::DEFAULT_ATTRIBUTE symbol with a class
-    class DEFAULT_ATTRIBUTE; end # rubocop: disable Naming/ClassAndModuleCamelCase
-  end
-end
-
-module Inspec
-  class Input
-
-    class Error < Inspec::Error; end
-    class ValidationError < Error
-      attr_accessor :input_name
-      attr_accessor :input_value
-      attr_accessor :input_type
-    end
-    class TypeError < Error
-      attr_accessor :input_type
-    end
-    class RequiredError < Error
-      attr_accessor :input_name
-    end
-
-    #===========================================================================#
-    #                        Class Input::Event
-    #===========================================================================#
-
-    # TODO: break this out to its own file under inspec/input?
-    # Information about how the input obtained its value.
-    # Each time it changes, an Input::Event is added to the #events array.
-    class Event
-      EVENT_PROPERTIES = [
-        :action,   # :create, :set, :fetch
-        :provider, # Name of the plugin
-        :priority, # Priority of this plugin for resolving conflicts.  1-100, higher numbers win.
-        :value,    # New value, if provided.
-        :file,     # File containing the input-changing action, if known
-        :line,     # Line in file containing the input-changing action, if known
-        :hit,      # if action is :fetch, true if the remote source had the input
-      ].freeze
-
-      # Value has a special handler
-      EVENT_PROPERTIES.reject { |p| p == :value }.each do |prop|
-        attr_accessor prop
-      end
-
-      attr_reader :value
-
-      def initialize(properties = {})
-        @value_has_been_set = false
-
-        properties.each do |prop_name, prop_value|
-          if EVENT_PROPERTIES.include? prop_name
-            # OK, save the property
-            send((prop_name.to_s + "=").to_sym, prop_value)
-          else
-            raise "Unrecognized property to Input::Event: #{prop_name}"
-          end
-        end
-      end
-
-      def value=(the_val)
-        # Even if set to nil or false, it has indeed been set; note that fact.
-        @value_has_been_set = true
-        @value = the_val
-      end
-
-      def value_has_been_set?
-        @value_has_been_set
-      end
-
-      def diagnostic_string
-        to_h.reject { |_, val| val.nil? }.to_a.map { |pair| "#{pair[0]}: '#{pair[1]}'" }.join(", ")
-      end
-
-      def to_h
-        EVENT_PROPERTIES.each_with_object({}) do |prop, hash|
-          hash[prop] = send(prop)
-        end
-      end
-
-      def self.probe_stack
-        frames = caller_locations(2, 40)
-        frames.reject! { |f| f.path && f.path.include?("/lib/inspec/") }
-        frames.first
-      end
-    end # class Event
-
-    #===========================================================================#
-    #                    Class NO_VALUE_SET
-    #===========================================================================#
-    # This special class is used to represent the value when an input has
-    # not been assigned a value. This allows a user to explicitly assign nil
-    # to an input.
-    class NO_VALUE_SET # rubocop: disable Naming/ClassAndModuleCamelCase
-      def initialize(name)
-        @name = name
-
-        # output warn message if we are in a exec call
-        if Inspec::BaseCLI.inspec_cli_command == :exec
-          Inspec::Log.warn(
-            "Input '#{@name}' does not have a value. "\
-            "Use --input-file to provide a value for '#{@name}' or specify a  "\
-            "value with `attribute('#{@name}', value: 'somevalue', ...)`."
-          )
-        end
-      end
-
-      def method_missing(*_)
-        self
-      end
-
-      def respond_to_missing?(_, _)
-        true
-      end
-
-      def to_s
-        "Input '#{@name}' does not have a value. Skipping test."
-      end
-
-      def is_a?(klass)
-        if klass == Inspec::Attribute::DEFAULT_ATTRIBUTE
-          Inspec.deprecate(:rename_attributes_to_inputs, "Don't check for `is_a?(Inspec::Attribute::DEFAULT_ATTRIBUTE)`, check for `Inspec::Input::NO_VALUE_SET")
-          true # lie for backward compatibility
-        else
-          super(klass)
-        end
-      end
-
-      def kind_of?(klass)
-        if klass == Inspec::Attribute::DEFAULT_ATTRIBUTE
-          Inspec.deprecate(:rename_attributes_to_inputs, "Don't check for `kind_of?(Inspec::Attribute::DEFAULT_ATTRIBUTE)`, check for `Inspec::Input::NO_VALUE_SET")
-          true # lie for backward compatibility
-        else
-          super(klass)
-        end
-      end
-    end # class NO_VALUE_SET
-
-    #===========================================================================#
-    #                       Class Inspec::Input
-    #===========================================================================#
-
-    # Validation types for input values
-    VALID_TYPES = %w{
-      String
-      Numeric
-      Regexp
-      Array
-      Hash
-      Boolean
-      Any
-    }.freeze
-
-    # TODO: this is not used anywhere?
-    # If you call `input` in a control file, the input will receive this priority.
-    # You can override that with a :priority option.
-    DEFAULT_PRIORITY_FOR_DSL_ATTRIBUTES = 20
-
-    # If you somehow manage to initialize an Input outside of the DSL,
-    # AND you don't provide an Input::Event, this is the priority you get.
-    DEFAULT_PRIORITY_FOR_UNKNOWN_CALLER = 10
-
-    # If you directly call value=, this is the priority assigned.
-    # This is the highest priority within InSpec core; though plugins
-    # are free to go higher.
-    DEFAULT_PRIORITY_FOR_VALUE_SET = 60
-
-    attr_reader :description, :events, :identifier, :name, :required, :title, :type
-
-    def initialize(name, options = {})
-      @name = name
-      @opts = options
-      if @opts.key?(:default)
-        Inspec.deprecate(:attrs_value_replaces_default, "input name: '#{name}'")
-        if @opts.key?(:value)
-          Inspec::Log.warn "Input #{@name} created using both :default and :value options - ignoring :default"
-          @opts.delete(:default)
-        end
-      end
-
-      # Array of Input::Event objects.  These compete with one another to determine
-      # the value of the input when value() is called, as well as providing a
-      # debugging record of when and how the value changed.
-      @events = []
-      events.push make_creation_event(options)
-
-      update(options)
-    end
-
-    # TODO: is this here just for testing?
-    def set_events
-      events.select { |e| e.action == :set }
-    end
-
-    def diagnostic_string
-      "Input #{name}, with history:\n" +
-        events.map(&:diagnostic_string).map { |line| "  #{line}" }.join("\n")
-    end
-
-    #--------------------------------------------------------------------------#
-    #                           Managing Value
-    #--------------------------------------------------------------------------#
-
-    def update(options)
-      _update_set_metadata(options)
-      normalize_type_restriction!
-
-      # Values are set by passing events in; but we can also infer an event.
-      if options.key?(:value) || options.key?(:default)
-        if options.key?(:event)
-          if options.key?(:value) || options.key?(:default)
-            Inspec::Log.warn "Do not provide both an Event and a value as an option to attribute('#{name}') - using value from event"
-          end
-        else
-          self.class.infer_event(options) # Sets options[:event]
-        end
-      end
-      events << options[:event] if options.key? :event
-
-      enforce_type_restriction!
-    end
-
-    # We can determine a value:
-    # 1. By event.value (preferred)
-    # 2. By options[:value]
-    # 3. By options[:default] (deprecated)
-    def self.infer_event(options)
-      # Don't rely on this working; you really should be passing a proper Input::Event
-      # with the context information you have.
-      location = Input::Event.probe_stack
-      event = Input::Event.new(
-        action: :set,
-        provider: options[:provider] || :unknown,
-        priority: options[:priority] || Inspec::Input::DEFAULT_PRIORITY_FOR_UNKNOWN_CALLER,
-        file: location.path,
-        line: location.lineno
-      )
-
-      if options.key?(:default)
-        Inspec.deprecate(:attrs_value_replaces_default, "attribute name: '#{name}'")
-        if options.key?(:value)
-          Inspec::Log.warn "Input #{@name} created using both :default and :value options - ignoring :default"
-          options.delete(:default)
-        else
-          options[:value] = options.delete(:default)
-        end
-      end
-      event.value = options[:value] if options.key?(:value)
-      options[:event] = event
-    end
-
-    private
-
-    def _update_set_metadata(options)
-      # Basic metadata
-      @title = options[:title] if options.key?(:title)
-      @description = options[:description] if options.key?(:description)
-      @required = options[:required] if options.key?(:required)
-      @identifier = options[:identifier] if options.key?(:identifier) # TODO: determine if this is ever used
-      @type = options[:type] if options.key?(:type)
-    end
-
-    def make_creation_event(options)
-      loc = options[:location] || Event.probe_stack
-      Input::Event.new(
-        action: :create,
-        provider: options[:provider],
-        file: loc.path,
-        line: loc.lineno
-      )
-    end
-
-    # Determine the current winning value, but don't validate it
-    def current_value
-      # Examine the events to determine highest-priority value. Tie-break
-      # by using the last one set.
-      events_that_set_a_value = events.select(&:value_has_been_set?)
-      winning_priority = events_that_set_a_value.map(&:priority).max
-      winning_events = events_that_set_a_value.select { |e| e.priority == winning_priority }
-      winning_event = winning_events.last # Last for tie-break
-
-      if winning_event.nil?
-        # No value has been set - return special no value object
-        NO_VALUE_SET.new(name)
-      else
-        winning_event.value # May still be nil
-      end
-    end
-
-    public
-
-    def value=(new_value, priority = DEFAULT_PRIORITY_FOR_VALUE_SET)
-      # Inject a new Event with the new value.
-      location = Event.probe_stack
-      events << Event.new(
-        action: :set,
-        provider: :value_setter,
-        priority: priority,
-        value: new_value,
-        file: location.path,
-        line: location.lineno
-      )
-      enforce_type_restriction!
-    end
-
-    def value
-      enforce_required_validation!
-      current_value
-    end
-
-    def has_value?
-      !current_value.is_a? NO_VALUE_SET
-    end
-
-    def to_hash
-      as_hash = { name: name, options: {} }
-      %i{description title identifier type required value}.each do |field|
-        val = send(field)
-        next if val.nil?
-
-        as_hash[:options][field] = val
-      end
-      as_hash
-    end
-
-    #--------------------------------------------------------------------------#
-    #                           Value Type Coercion
-    #--------------------------------------------------------------------------#
-
-    def to_s
-      "Input #{name} with #{current_value}"
-    end
-
-    #--------------------------------------------------------------------------#
-    #                               Validation
-    #--------------------------------------------------------------------------#
-
-    private
-
-    def enforce_required_validation!
-      return unless required
-      # skip if we are not doing an exec call (archive/vendor/check)
-      return unless Inspec::BaseCLI.inspec_cli_command == :exec
-
-      proposed_value = current_value
-      if proposed_value.nil? || proposed_value.is_a?(NO_VALUE_SET)
-        error = Inspec::Input::RequiredError.new
-        error.input_name = name
-        raise error, "Input '#{error.input_name}' is required and does not have a value."
-      end
-    end
-
-    def enforce_type_restriction! # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      return unless type
-      return unless has_value?
-
-      type_req = type
-      return if type_req == "Any"
-
-      proposed_value = current_value
-
-      invalid_type = false
-      if type_req == "Regexp"
-        invalid_type = true unless valid_regexp?(proposed_value)
-      elsif type_req == "Numeric"
-        invalid_type = true unless valid_numeric?(proposed_value)
-      elsif type_req == "Boolean"
-        invalid_type = true unless [true, false].include?(proposed_value)
-      elsif proposed_value.is_a?(Module.const_get(type_req)) == false
-        # TODO: why is this case here?
-        invalid_type = true
-      end
-
-      if invalid_type == true
-        error = Inspec::Input::ValidationError.new
-        error.input_name = @name
-        error.input_value = proposed_value
-        error.input_type = type_req
-        raise error, "Input '#{error.input_name}' with value '#{error.input_value}' does not validate to type '#{error.input_type}'."
-      end
-    end
-
-    def normalize_type_restriction!
-      return unless type
-
-      type_req = type.capitalize
-      abbreviations = {
-        "Num" => "Numeric",
-        "Regex" => "Regexp",
-      }
-      type_req = abbreviations[type_req] if abbreviations.key?(type_req)
-      unless VALID_TYPES.include?(type_req)
-        error = Inspec::Input::TypeError.new
-        error.input_type = type_req
-        raise error, "Type '#{error.input_type}' is not a valid input type."
-      end
-      @type = type_req
-    end
-
-    def valid_numeric?(value)
-      Float(value)
-      true
-    rescue
-      false
-    end
-
-    def valid_regexp?(value)
-      # check for invalid regex syntax
-      Regexp.new(value)
-      true
-    rescue
-      false
-    end
-  end
-end