cem_acpt 0.8.8 → 0.9.1

data/lib/cem_acpt/test_runner.rb

@@ -2,7 +2,8 @@
 
 require 'fileutils'
 require 'securerandom'
-require_relative 'action_result'
+require_relative 'actions'
+require_relative 'bolt'
 require_relative 'goss'
 require_relative 'logging'
 require_relative 'platform'
@@ -11,6 +12,7 @@ require_relative 'test_data'
 require_relative 'utils'
 require_relative 'version'
 require_relative 'test_runner/log_formatter'
+require_relative 'test_runner/test_results'
 
 module CemAcpt
   # Namespace for all Runner-related classes and modules
@@ -19,6 +21,8 @@ module CemAcpt
     class Runner
       include CemAcpt::Logging
 
+      SUCCESS_STATUS = [200, 0].freeze
+
       attr_reader :duration, :exit_code
       attr_accessor :run_data # This is opened up mainly for windows use.
 
@@ -27,8 +31,9 @@ module CemAcpt
         @run_data = {}
         @duration = 0
         @exit_code = 0
-        @results = []
-        @http_statuses = []
+        @bolt_test_runner = nil
+        @results = CemAcpt::TestRunner::TestResults.new
+        @statuses = []
         @provisioned = false
         @destroyed = false
       end
@@ -42,23 +47,14 @@ module CemAcpt
       end
 
       def run
-        @run_data = {}
         @start_time = Time.now
         module_dir = config.get('module_dir')
         @old_dir = Dir.pwd
         Dir.chdir(module_dir)
+        configure_actions
         logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run started at #{@start_time}")
         logger.info('CemAcpt::TestRunner') { "Using module directory: #{module_dir}..." }
-        @run_data[:private_key], @run_data[:public_key], @run_data[:known_hosts] = new_ephemeral_ssh_keys
-        logger.info('CemAcpt::TestRunner') { 'Created ephemeral SSH key pair...' }
-        @run_data[:module_package_path] = build_module_package
-        logger.info('CemAcpt::TestRunner') { "Created module package: #{@run_data[:module_package_path]}..." }
-        @run_data[:test_data] = new_test_data
-        logger.info('CemAcpt::TestRunner') { 'Created test data...' }
-        logger.verbose('CemAcpt::TestRunner') { "Test data: #{@run_data[:test_data]}" }
-        @run_data[:nodes] = new_node_data
-        logger.info('CemAcpt::TestRunner') { 'Created node data...' }
-        logger.verbose('CemAcpt::TestRunner') { "Node data: #{@run_data[:nodes]}" }
+        pre_provision_test_nodes
         provision_test_nodes
         @instance_names_ips = provisioner_output
         logger.info('CemAcpt::TestRunner') { "Instance names and IPs class: #{@instance_names_ips.class}" }
@@ -79,18 +75,17 @@ module CemAcpt
             win_node.run
           end
         end
-        @results = run_tests(@instance_names_ips.map { |_, v| v['ip'] },
-                              config.get('actions.only'),
-                              config.get('actions.except'))
+        @hosts = @instance_names_ips.map { |_, v| v['ip'] }
+        run_tests
       rescue StandardError => e
         logger.error('CemAcpt::TestRunner') { 'Run failed due to error...' }
-        @results << ActionResult.new(e)
+        @results << e
       ensure
         logger.end_ci_group
         clean_up
         process_test_results
         Dir.chdir(@old_dir) if @old_dir
-        @results
+        @results.to_a
       end
 
       def clean_up(_trap_context = false)
@@ -117,13 +112,36 @@ module CemAcpt
 
       attr_reader :config
 
+      # Configures the actions to run based on the config
+      def configure_actions
+        logger.info('CemAcpt::TestRunner') { 'Configuring and registering actions...' }
+        goss_actions = CemAcpt::Goss::Api::ACTIONS.keys
+        CemAcpt::Actions.configure(config) do |c|
+          c.register_group(:goss, order: 0).register_action(goss_actions.first) do |context|
+            run_goss_tests(context)
+          end
+          goss_actions[1..-1].each { |a| c[:goss].register_action(a) }
+          c.register_group(:bolt, order: 1).register_action(:bolt) do |context|
+            run_bolt_tests(context)
+          end
+        end
+        logger.debug('CemAcpt::TestRunner') { "All actions #{CemAcpt::Actions.config.action_names}" }
+        logger.debug('CemAcpt::TestRunner') { "Only actions: #{CemAcpt::Actions.config.only}" }
+        logger.debug('CemAcpt::TestRunner') { "Except actions: #{CemAcpt::Actions.config.except}" }
+        logger.info('CemAcpt::TestRunner') do
+          "Configured and registered actions, will run actions: #{CemAcpt::Actions.config.action_names.join(', ')}"
+        end
+      end
+
       # @return [String] The path to the module package
       def build_module_package
-        if config.get('tests').first.include? 'windows'
-          CemAcpt::Utils.package_win_module(config.get('module_dir'))
-        else
-          CemAcpt::Utils::Puppet.build_module_package(config.get('module_dir'))
-        end
+        pkg_path = if config.get('tests').first.include? 'windows'
+                     CemAcpt::Utils.package_win_module(config.get('module_dir'))
+                   else
+                     CemAcpt::Utils::Puppet.build_module_package(config.get('module_dir'))
+                   end
+        logger.info('CemAcpt::TestRunner') { "Created module package: #{pkg_path}..." }
+        pkg_path
       end
 
       # @return [Array<String>] The paths to the ssh private key, public key, and known hosts file
@@ -131,7 +149,9 @@ module CemAcpt
         return [nil, nil, nil] if config.get('no_ephemeral_ssh_key')
 
         logger.info('CemAcpt::TestRunner') { 'Creating ephemeral SSH keys...' }
-        CemAcpt::Utils::SSH::Ephemeral.create
+        pri, pub, kh = CemAcpt::Utils::SSH::Ephemeral.create
+        logger.info('CemAcpt::TestRunner') { 'Created ephemeral SSH key pair...' }
+        [pri, pub, kh]
       end
 
       def clean_ephemeral_ssh_keys
@@ -143,12 +163,45 @@ module CemAcpt
 
       def new_test_data
         logger.debug('CemAcpt::TestRunner') { 'Creating new test data...' }
-        CemAcpt::TestData.acceptance_test_data(config)
+        tdata = CemAcpt::TestData.acceptance_test_data(config)
+        logger.info('CemAcpt::TestRunner') { 'Created test data...' }
+        logger.verbose('CemAcpt::TestRunner') { "Test data:\n#{tdata}" }
+        tdata
       end
 
       def new_node_data
         logger.debug('CemAcpt::TestRunner') { 'Creating new node data...' }
-        CemAcpt::Platform.use(config.get('platform.name'), config, @run_data)
+        ndata = CemAcpt::Platform.use(config.get('platform.name'), config, @run_data)
+        logger.info('CemAcpt::TestRunner') { 'Created node data...' }
+        logger.verbose('CemAcpt::TestRunner') { "Node data:\n#{ndata}" }
+        ndata
+      end
+
+      # Runs all methods that are needed to prep data and environment for the provision_test_nodes method
+      def pre_provision_test_nodes
+        logger.info('CemAcpt::TestRunner') { 'Pre-provisioning test nodes...' }
+        logger.info('CemAcpt::TestRunner') { 'Creating initial run data...' }
+        @run_data = {}
+        @run_data[:private_key], @run_data[:public_key], @run_data[:known_hosts] = new_ephemeral_ssh_keys
+        @run_data[:module_package_path] = build_module_package
+        @run_data[:test_data] = new_test_data
+        @run_data[:nodes] = new_node_data
+        logger.verbose('CemAcpt::TestRunner') { "Initial run data:\n#{@run_data}" }
+        logger.info('CemAcpt::TestRunner') { 'Created initial run data...' }
+        setup_bolt
+      end
+
+      def setup_bolt
+        logger.info('CemAcpt::TestRunner') { 'Setting up Bolt...' }
+        @bolt_test_runner = CemAcpt::Bolt::TestRunner.new(config, run_data: @run_data)
+        @bolt_test_runner.setup!
+        return unless @bolt_test_runner.tests.to_a.empty?
+
+        if !only_actions.empty? && only_actions.include?('bolt')
+          raise 'No Bolt tests to run and only bolt action was specified'
+        end
+
+        logger.warn('CemAcpt::TestRunner') { 'No Bolt tests to run' }
       end
 
       def provision_test_nodes
@@ -194,20 +247,60 @@ module CemAcpt
         logger.info('CemAcpt') { "Test SSH Keys:\n  Private Key: #{@run_data[:private_key]}\n  Public Key:#{@run_data[:public_key]}" }
       end
 
-      def run_tests(hosts, only_actions, except_actions)
-        logger.info('CemAcpt::TestRunner') { 'Running tests...' }
-        logger.verbose('CemAcpt::TestRunner') { "Hosts: #{hosts}" }
-        logger.verbose('CemAcpt::TestRunner') { "Only actions: #{only_actions}" }
-        logger.verbose('CemAcpt::TestRunner') { "Except actions: #{except_actions}" }
-        api_results = CemAcpt::Goss::Api.run_actions_async(hosts,
-                                                           only: only_actions || [],
-                                                           except: except_actions || [])
-        res = []
-        api_results.close unless api_results.closed?
-        while (r = api_results.pop)
-          res << ActionResult.new(r)
+      def run_tests
+        logger.info('CemAcpt::TestRunner') { 'Preparing to run tests...' }
+        logger.verbose('CemAcpt::TestRunner') { "Hosts: #{@hosts}" }
+        logger.verbose('CemAcpt::TestRunner') { "Only actions: #{CemAcpt::Actions.only}" }
+        logger.verbose('CemAcpt::TestRunner') { "Except actions: #{CemAcpt::Actions.except}" }
+        @results = CemAcpt::TestRunner::TestResults.new(config, @instance_names_ips)
+        CemAcpt::Actions.execute
+      end
+
+      def run_goss_tests(context = {})
+        logger.info('CemAcpt::TestRunner') { 'Running goss tests...' }
+        context[:hosts] = @hosts
+        context[:results] = @results
+        CemAcpt::Goss::Api.run_actions_async(context)
+      end
+
+      def run_bolt_tests(_context = {})
+        logger.info('CemAcpt::TestRunner') { 'Running Bolt tests...' }
+        # If the Bolt config has tests:only or tests:ignore lists, we need to filter the hosts
+        # based on their associated tests.
+        @bolt_test_runner.hosts = filtered_bolt_hosts
+        @bolt_test_runner.run
+        @results << @bolt_test_runner.results
+      end
+
+      def filtered_bolt_hosts
+        tests_only = config.get('bolt.tests.only')
+        tests_only_unset = tests_only.nil? || tests_only.empty?
+        logger.debug('CemAcpt::TestRunner') { "Bolt tests only: #{tests_only}" } unless tests_only_unset
+        tests_ignore = config.get('bolt.tests.ignore')
+        tests_ignore_unset = tests_ignore.nil? || tests_ignore.empty?
+        logger.debug('CemAcpt::TestRunner') { "Bolt tests ignore: #{tests_ignore}" } unless tests_ignore_unset
+        return @instance_names_ips.map { |_, v| v['ip'] } if tests_only_unset && tests_ignore_unset
+
+        logger.debug('CemAcpt::TestRunner') { 'Filtering Bolt hosts...' }
+        filtered_hosts = []
+        @instance_names_ips.each do |_, v|
+          host = v['ip']
+          test_name = v['test_name']
+          in_only = !tests_only_unset && tests_only.include?(test_name)
+          in_ignore = !tests_ignore_unset && tests_ignore.include?(test_name)
+          if in_only || !in_ignore
+            filtered_hosts << host
+            logger.debug('CemAcpt::TestRunner') { "Added host #{host} to filtered hosts" }
+          else
+            logger.debug('CemAcpt::TestRunner') do
+              "Not adding host #{host} to filtered hosts. In only? #{in_only}; In ignore? #{in_ignore}"
+            end
+          end
         end
-        res
+        filtered_hosts.compact!
+        filtered_hosts.uniq!
+        logger.debug('CemAcpt::TestRunner') { "Filtered hosts: #{filtered_hosts}" }
+        filtered_hosts
       end
 
       def process_test_results
@@ -218,14 +311,14 @@ module CemAcpt
           logger.info('CemAcpt::TestRunner') { "Processing #{@results.size} test result(s)..." }
           until @results.empty?
             result = @results.pop
-            @http_statuses << result.http_status
+            @statuses << result.status
             log_test_result(result)
           end
-          if @http_statuses.empty?
+          if @statuses.empty?
             logger.error('CemAcpt::TestRunner') { 'No test results to process' }
             @exit_code = 1
           else
-            @exit_code = (@http_statuses.any? { |s| s.to_i != 200 }) ? 1 : 0
+            @exit_code = (@statuses.any? { |s| SUCCESS_STATUS.include?(s.to_i) }) ? 1 : 0
           end
         end
         @duration = Time.now - @start_time
@@ -233,13 +326,22 @@ module CemAcpt
       end
 
       def log_test_result(result)
-        result_log_formatter = LogFormatter.new_formatter(result, config, @instance_names_ips)
-        logger.start_ci_group("Test results for #{result_log_formatter.test_name(result)}")
-        return log_error_test_result(result_log_formatter, result) if result.error?
+        logger.start_ci_group("Test results for #{result.log_formatter.test_name}")
+        case result
+        when CemAcpt::TestRunner::TestResults::TestErrorActionResult
+          log_error_test_result(result)
+        when CemAcpt::TestRunner::TestResults::TestActionResult
+          log_action_test_result(result)
+        else
+          raise ArgumentError, "result must be a CemAcpt::TestRunner::TestResults::TestActionResult or CemAcpt::TestRunner::TestResults::TestErrorActionResult, got #{result.class}"
+        end
+      ensure
+        logger.end_ci_group
+      end
 
-        logger.info(result_log_formatter.summary(result))
-        formatted_results = result_log_formatter.results(result)
-        formatted_results.each do |r|
+      def log_action_test_result(result)
+        logger.info { result.log_formatter.summary }
+        result.log_formatter.results.each do |r|
           if r.start_with?('Passed:')
             logger.verbose { r }
           elsif r.start_with?('Skipped:')
@@ -248,12 +350,10 @@ module CemAcpt
             logger.error { r }
           end
         end
-      ensure
-        logger.end_ci_group
       end
 
-      def log_error_test_result(formatter, result)
-        logger.fatal { formatter.results(result).join("\n") }
+      def log_error_test_result(result)
+        logger.fatal { result.log_formatter.results.join("\n") }
       end
 
       # Upload the cem_windows module to the bucket if we're testing the cem_windows module

data/lib/cem_acpt/utils/files.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../logging'
+
+module CemAcpt
+  module Utils
+    # Utility classes and methods for files
+    module Files
+      class << self
+        # Reads a file based on its extension
+        # @param file [String] Path to the file
+        # @param log_level [Symbol] Log level to use
+        # @param log_prefix [String] Log prefix to use
+        # @param kwargs [Hash] Keyword arguments to pass to the file utility
+        # @option kwargs [String] :log_msg Log message to use when logging the file operation
+        # @option kwargs [Array] :permitted_classes Array of classes to permit when loading YAML files
+        # @return [Object] The result of the file utility's read method
+        def read(file, *args, log_level: :debug, log_prefix: 'CemAcpt', **kwargs)
+          return from_content_registry(file, :content) unless file_changed?(file)
+
+          content = new_file_util_for(file, log_level: log_level, log_prefix: log_prefix).read(file, *args, **kwargs)
+          add_to_content_registry(file, :content, content)
+          content
+        end
+
+        def write(file, content, *args, log_level: :debug, log_prefix: 'CemAcpt', **kwargs)
+          new_file_util_for(file, log_level: log_level, log_prefix: log_prefix).write(file, content, *args, **kwargs)
+        end
+
+        def delete(file, *args, log_level: :debug, log_prefix: 'CemAcpt', **kwargs)
+          new_file_util_for(file, log_level: log_level, log_prefix: log_prefix).delete(file, *args, **kwargs)
+        end
+
+        private
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+
+        def content_registry
+          @content_registry ||= {}
+        end
+
+        def file_changed?(file)
+          return true unless File.exist?(file)
+          fstat = File.stat(file)
+          rmtime = from_content_registry(file, :mtime)
+          check_res = rmtime.nil? || (fstat.mtime != rmtime)
+          add_to_content_registry(file, :mtime, fstat.mtime)
+          check_res
+        end
+
+        def add_to_content_registry(file, property, value)
+          mutex.synchronize do
+            content_registry[file] ||= {}
+            content_registry[file][property.to_sym] = value
+          end
+        end
+
+        def from_content_registry(file, property)
+          mutex.synchronize do
+            content_registry[file] ||= {}
+            content_registry[file][property.to_sym]
+          end
+        end
+
+        def new_file_util_for(file, log_level: :debug, log_prefix: 'CemAcpt')
+          case File.extname(file)
+          when *YamlUtil::VALID_EXTS
+            YamlUtil.new(log_level: log_level, log_prefix: log_prefix)
+          when *JsonUtil::VALID_EXTS
+            JsonUtil.new(log_level: log_level, log_prefix: log_prefix)
+          else
+            FileUtil.new(log_level: log_level, log_prefix: log_prefix)
+          end
+        end
+      end
+
+      # Generic file utility class
+      class FileUtil
+        include CemAcpt::Logging
+
+        attr_reader :log_level, :log_prefix, :file_exts
+
+        def initialize(log_level: :debug, log_prefix: 'CemAcpt', file_exts: [])
+          @log_level = log_level
+          @log_prefix = log_prefix
+          @file_exts = file_exts
+        end
+
+        def log_level=(level)
+          level = level.downcase.to_sym
+          raise ArgumentError, "Invalid log level #{level}" unless logger.respond_to?(level)
+
+          @log_level = level
+        end
+
+        def log_prefix=(prefix)
+          @log_prefix = prefix.to_s
+        end
+
+        def file_exts=(exts)
+          raise ArgumentError, 'file_exts must be an Array' unless exts.is_a?(Array)
+
+          @file_ext = exts
+        end
+
+        def write(file, content, *_args, log_msg: 'Writing file %s...', **_kwargs)
+          validate_and_log(file, log_msg)
+          File.write(file, content)
+        end
+
+        def read(file, *_args, log_msg: 'Reading file %s...', **_kwargs)
+          validate_and_log(file, log_msg)
+          File.read(file)
+        end
+
+        def delete(file, *_args, log_msg: 'Deleting file %s...', **_kwargs)
+          validate_and_log(file, log_msg)
+          FileUtils.rm_f(file)
+        end
+
+        private
+
+        def validate_and_log(file, log_msg)
+          file = validate_ext(file)
+          logger.send(log_level, log_prefix) { log_msg.to_s % file }
+        end
+
+        def validate_ext(file)
+          return if file_exts.empty?
+
+          ext = File.extname(file)
+          raise ArgumentError, "Invalid file extension #{ext}! Valid file extensions are #{file_exts}" unless file_exts.include?(ext)
+        end
+      end
+
+      # Utility class for working with YAML files
+      class YamlUtil < FileUtil
+        VALID_EXTS = %w[.yaml .yml].freeze
+        DEFAULT_PERMITTED_CLASSES = [Symbol].freeze
+
+        def initialize(log_level: :debug, log_prefix: 'CemAcpt', file_exts: VALID_EXTS)
+          super(log_level: log_level, log_prefix: log_prefix, file_exts: file_exts)
+          require 'yaml'
+        end
+
+        def write(file, content, *_args, log_msg: 'Writing YAML file %s...', **_kwargs)
+          raise ArgumentError, 'content must be a Hash' unless content.is_a?(Hash)
+
+          super(file, content.to_yaml, log_msg)
+        end
+
+        def read(file, *_args, log_msg: 'Reading YAML file %s...', permitted_classes: DEFAULT_PERMITTED_CLASSES, **_kwargs)
+          YAML.safe_load(super(file, log_msg), permitted_classes: permitted_classes)
+        end
+
+        def delete(file, *_args, log_msg: 'Deleting YAML file %s...', **_kwargs)
+          super(file, log_msg)
+        end
+      end
+
+      # Utility class for working with JSON files
+      class JsonUtil < FileUtil
+        VALID_EXTS = %w[.json].freeze
+
+        def initialize(log_level: :debug, log_prefix: 'CemAcpt', file_exts: VALID_EXTS)
+          super(log_level: log_level, log_prefix: log_prefix, file_exts: file_exts)
+          require 'json'
+        end
+
+        def write(file, content, *_args, log_msg: 'Writing JSON file %s...', **_kwargs)
+          raise ArgumentError, 'content must be a Hash' unless content.is_a?(Hash)
+
+          super(file, content.to_json, log_msg)
+        end
+
+        def read(file, *_args, log_msg: 'Reading JSON file %s...', **_kwargs)
+          JSON.parse(super(file, log_msg))
+        end
+
+        def delete(file, *_args, log_msg: 'Deleting JSON file %s...', **_kwargs)
+          super(file, log_msg)
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/utils/finalizer_queue.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module Utils
+    class FinalizerQueueError < StandardError; end
+
+    # A queue that can be finalized.
+    # When a queue is finalized, no more items can be added to it, and the
+    # queue is closed and converted to a frozen array.
+    class FinalizerQueue
+      def initialize
+        @queue = Queue.new
+        @array = []
+        @finalized = false
+        @mutex = Mutex.new
+      end
+
+      def finalize!
+        return if finalized?
+
+        @finalized = true
+        new_array
+      end
+
+      def finalized?
+        @finalized
+      end
+
+      def to_a
+        raise FinalizerQueueError, 'Cannot convert to array until finalized' unless finalized?
+
+        @array
+      end
+
+      def method_missing(method_name, *args, **kwargs, &block)
+        if finalized?
+          @array.send(method_name, *args, **kwargs, &block)
+        elsif @queue.respond_to?(method_name)
+          @queue.send(method_name, *args, **kwargs, &block)
+        else
+          super
+        end
+      rescue StandardError => e
+        raise e if e.is_a?(NoMethodError) || e.is_a?(FinalizerQueueError)
+
+        new_err = FinalizerQueueError.new("Error calling #{method_name} on FinalizerQueue: #{e}")
+        new_err.set_backtrace(e.backtrace)
+        raise new_err
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @array.respond_to?(method_name, include_private) if finalized?
+
+        super
+      end
+
+      private
+
+      def new_array
+        @queue.close unless @queue.closed?
+        @array << @queue.pop until @queue.empty?
+        @array.compact!
+        @array.freeze
+      end
+
+      def require_finalized(caller_binding)
+        return if finalized?
+
+        raise FinalizerQueueError, "Cannot call #{caller_binding.eval('__method__')} on unfinalized #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/cem_acpt/utils/shell.rb

@@ -6,6 +6,7 @@ require 'stringio'
 module CemAcpt
   # Error class for shell commands
   class ShellCommandError < StandardError; end
+  class ShellCommandNotFoundError < ShellCommandError; end
 
   module Utils
     # Generic utilities for running local shell commands
@@ -23,7 +24,7 @@ module CemAcpt
         io_outerr = StringIO.new
         if output.respond_to?(:debug)
           output.debug('CemAcpt::Utils::Shell') { "Running command:\n\t#{cmd}\nWith environment:\n\t#{env}" }
-        else
+        elsif output
           output << "Running command:\n\t#{cmd}\nWith environment:\n\t#{env}\n"
         end
         val = Open3.popen2e(env, cmd) do |stdin, outerr, wait_thr|
@@ -47,18 +48,26 @@ module CemAcpt
 
       # Mimics the behavior of the `which` command.
       # @param cmd [String] The command to find
-      # @return [String] The path to the command
-      # @return [nil] If the command is not found
-      def self.which(cmd)
+      # @param include_ruby_bin [Boolean] Whether to include Ruby bin directories in the search.
+      #   Setting this to true can cause errors to be raised if cem_acpt attempts to use a Ruby
+      #   command that is not available to cem_acpt, such as when running with `bundle exec`.
+      # @param raise_if_not_found [Boolean] Whether to raise an error if the command is not found
+      # @return [String, nil] The path to the command or nil if not found
+      # @raise [CemAcpt::ShellCommandNotFoundError] If the command is not found and raise_if_not_found is true
+      def self.which(cmd, include_ruby_bin: false, raise_if_not_found: false)
         return cmd if File.executable?(cmd) && !File.directory?(cmd)
 
         exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
         ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          next if path.include?('/ruby') && !include_ruby_bin
+
           exts.each do |ext|
             exe = File.join(path, "#{cmd}#{ext}")
             return exe if File.executable?(exe) && !File.directory?(exe)
           end
         end
+        raise CemAcpt::ShellCommandNotFoundError, "Command #{cmd} not found in PATH" if raise_if_not_found
+
         nil
       end
     end

data/lib/cem_acpt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CemAcpt
-  VERSION = '0.8.8'
+  VERSION = '0.9.1'
 end

data/sample_config.yaml

@@ -58,6 +58,19 @@ tests:
   # - stig_rhel-7_firewalld_public_3
   # - stig_rhel-8_firewalld_public_3
 
+bolt:
+  project:
+    name: 'cem-acpt'
+    analytics: false
+  tests:
+    only: [] # Test names from the "tests" array above
+    ignore: []
+  tasks:
+    ignore: [] # Task names to ignore
+    only: []
+    module_pattern: '^.*$'
+    name_filter: '^fake_task$'
+
 cem_acpt_image:
   no_windows: true
   no_linux: false