cem_acpt 0.2.8-universal-java-17 → 0.2.11-universal-java-17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bf596ee67704455f907b1d68959a733bf938051108534dad444942de893e3cf
-  data.tar.gz: 9d47ed4ca9975d124d2550e51bcf00c945ad5f10b21c8fb8205f27365bd7f76b
+  metadata.gz: c97a0886b1604384a7e03f5edec960b594842f69502e5b1fcd4d2a6a18ecb3fc
+  data.tar.gz: 8ad5f879c25f70d0050ec0f7fd24891339b7a80271193d2549e8a6a7224d7727
 SHA512:
-  metadata.gz: 16bdac45fb5384f85863967f64fa927a5bd610b483d6eab4f87cf45c55117cbe7fda818259f8b42fda621d9118bb46b8099fa7c7f5cd52a12d567691f729cc39
-  data.tar.gz: a3957f255f0643f6102df4c32628d21ebfe6f51d7cba25a122be80b48e5288a2569830f1a0995298db082a4bb79e64570af9de1617c3e2ed4f812a83c33f8a02
+  metadata.gz: 2279fa0e8ab932d0f02982cf8cacf6aaf4bf8c0a5e709eeb7e3cd0d093a4712f501c175f2a57f64cd0c441e56fa0c51e4238ab1a196d89037f719194981536a1
+  data.tar.gz: 76ca3f9c58e4f1450b3e442b0edc825b68ea5b533796b34e90963630dc219731238128f44dbe1267979199d06efa1a3cef99913318bb3684af663e377ec8b97f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_acpt (0.2.8-universal-java-17)
+    cem_acpt (0.2.11-universal-java-17)
       concurrent-ruby (>= 1.1, < 2.0)
       deep_merge (>= 1.2, < 2.0)
       ed25519 (>= 1.2, < 2.0)
@@ -68,7 +68,7 @@ GEM
       rspec-its
       specinfra (~> 2.83.1)
     sfl (2.3)
-    specinfra (2.83.2)
+    specinfra (2.83.3)
       net-scp
       net-ssh (>= 2.7)
       net-telnet (= 0.1.1)

data/README.md

@@ -1,8 +1,8 @@
 # CemAcpt
 
-CemAcpt is an acceptance testing library / command line application for running acceptance tests against the CEM modules. It is heavily inspired by Puppet Litmus. CemAcpt is fully compatible with Puppet Litmus acceptance tests.
+CemAcpt is an acceptance testing library / command line application for running acceptance tests for the CEM modules. It is heavily inspired by Puppet Litmus. CemAcpt is fully compatible with Puppet Litmus acceptance tests.
 
-CemAcpt was written to facilitate running a single acceptance test file against one or more test nodes concurrently. This is useful when your module supports a lot of different operating systems and modifies low-level components of those operating systems. For CEM, we manage things such as firewall and bootloader configurations which requires us to test against multiple base images of a single operating system (i.e. RHEL 8 with `iptables` and RHEL 8 with `firewalld`). Additionally, we test our module using both Puppet 6 and Puppet 7. As you can see, we now need to test against four test nodes that are all RHEL 8 with slightly different baseline configs. CemAcpt allows us to do so quickly in parallel.
+CemAcpt was written to facilitate running a single acceptance test file against one or more individual test nodes concurrently, and have each additional acceptance test file do the same. This is useful when your module supports a lot of different operating systems and modifies low-level components of those operating systems. For CEM, we manage things such as firewall and bootloader configurations which requires us to test against multiple base images of a single operating system (i.e. RHEL 8 with `iptables` and RHEL 8 with `firewalld`). Additionally, we test our module using both Puppet 6 and Puppet 7. As you can see, we now need to test against four test nodes that are all RHEL 8 with slightly different baseline configs. CemAcpt allows us to do so quickly in parallel.
 
 Major differences between Puppet Litmus and CemAcpt are:
 
@@ -10,8 +10,72 @@ Major differences between Puppet Litmus and CemAcpt are:
 - Test node image names can be dynamically defined by configurable parsing of the acceptance test name.
   - This allows your acceptance test names to define the node it will run against.
 - CemAcpt has it's own CLI for running provisioning of hosts and the test suite and does not use `rake`.
-- CemAcpt runs everything, including provisioning the test node, creating a temporary manifest on the test node, and running the acceptance test on the test node, in parallel. No matter how many test / host combinations there are, running the test suite will only take as long as the longest running single test / host combo.
+- CemAcpt runs everything, including provisioning the test node(s), creating a temporary manifest on the test node(s), and running the acceptance test on the test node(s), in parallel. No matter how many test / host combinations there are, running the test suite will only take as long as the longest running single test / host combo.
 - CemAcpt is configurable via a YAML file.
+- CemAcpt provides extensive logging, including the ability to save logs to a file and an option to format log output on `stdout` specifically for GitHub Actions.
+
+## Installation
+
+### Command-line usage
+
+Assuming cem_acpt is already configured in your Puppet module, you can run cem_acpt from your command line.
+
+`cem_acpt` require JRuby 9.3.3.0 or greater. To install and use JRuby with `rvm`:
+
+```
+rvm install jruby-9.3.3.0
+rvm use jruby-9.3.3.0
+# If you have a Gemfile.lock already
+rm Gemfile.lock
+bundle install
+jruby --server <jruby opts> -S bundle exec cem_acpt <opts>
+```
+
+> If you do not delete Gemfile.lock before running `bundle install`, you will most likely encounter dependency version errors. Just delete Gemfile.lock and run `bundle install` again to get past these.
+
+### Installing into a Puppet module
+
+Add this line to your module's Gemfile (usually under `group :development`):
+
+```ruby
+gem 'cem_acpt', require: false
+```
+
+Then, add the following to your `spec_helper_acceptance.rb` (replacing the Puppet Litmus configuration lines):
+
+```ruby
+require 'cem_acpt'
+
+CemAcpt.configure_spec_helper!
+```
+
+To use CemAcpt in your acceptance tests, you must call the method `initialize_test_environment!` in your acceptance test's `describe` block before doing anything else:
+
+```ruby
+describe 'cem_linux CIS Level 1' do
+  initialize_test_environment!
+  ...
+```
+
+## Usage
+
+### RSpec methods
+
+CemAcpt enables you to use all ServerSpec methods in your acceptance tests, and adds three new methods that can be used (these methods are used the same as in Litmus):
+
+- `apply_manifest(manifest, opts = {})`: Applies a Puppet manifest given as a string.
+- `idempotent_apply(manifest, opts = {})`: Applies a Puppet manifest given as a string twice and fails if the second apply reports changes.
+- `run_shell(command, opts = {})`: Runs a shell command against the test node.
+
+### Config file
+
+CemAcpt can use a config file (default path is `./cem_acpt_config.yaml`) to configure it's settings. Below are some of the options available in the config file:
+
+- `tests`: An array of test names you want to run. These are assumed to exist in the path `spec/acceptance`. You should leave off the suffix `_spec.rb` from the test file names.
+- `platform`: The backend platform that acceptance tests will run on. Currently, only `gcp` is supported.
+- `test_data`: Configurations for test data. Allows assigning variables to test data either dynamically or statically.
+- `node_data`: Configurations for nodes created by the platform. The available options are platform-dependent.
+- `image_name_builder`: If this key is specified, platforms will be passed a dynamically generated image name based on the configurations under this key.
 
 ## Concepts
 
@@ -79,62 +143,6 @@ Rules that allow for processing variables after all other test data rules are ra
 
 Much like `name_pattern_vars`, specifying the `image_name_builder` top-level key in the config allows you to manipulate acceptance test names to create a special test data variable called `image_name`. This is helpful for when you have multiple platform base images and want to use the correct image with the correct test. See [sample_config.yaml](sample_config.yaml) for an example.
 
-## Installation
-
-### Installing from RubyGems
-
-To install the gem locally to use as a CLI tool:
-
-`gem install cem_acpt --prerelease`
-
-### Installing into a Puppet module
-
-Add this line to your module's Gemfile (usually under `group :development`):
-
-```ruby
-gem 'cem_acpt', require: false
-```
-
-Then, add the following to your `spec_helper_acceptance.rb` (replacing the Puppet Litmus configuration lines):
-
-```ruby
-require 'cem_acpt'
-
-CemAcpt.configure_spec_helper!
-```
-
-To use CemAcpt in your acceptance tests, you must call the method `initialize_test_environment!` in your acceptance test's `describe` block before doing anything else:
-
-```ruby
-describe 'cem_linux CIS Level 1' do
-  initialize_test_environment!
-  ...
-```
-
-## Usage
-
-### RSpec methods
-
-CemAcpt enables you to use all ServerSpec methods in your acceptance tests, and adds three new methods that can be used (these methods are used the same as in Litmus):
-
-- `apply_manifest(manifest, opts = {})`: Applies a Puppet manifest given as a string.
-- `idempotent_apply(manifest, opts = {})`: Applies a Puppet manifest given as a string twice and fails if the second apply reports changes.
-- `run_shell(command, opts = {})`: Runs a shell command against the test node.
-
-### Config file
-
-CemAcpt can use a config file (default path is `./cem_acpt_config.yaml`) to configure it's settings. Below are some of the options available in the config file:
-
-- `tests`: An array of test names you want to run. These are assumed to exist in the path `spec/acceptance`. You should leave off the suffix `_spec.rb` from the test file names.
-- `platform`: The backend platform that acceptance tests will run on. Currently, only `gcp` is supported.
-- `test_data`: Configurations for test data. Allows assigning variables to test data either dynamically or statically.
-- `node_data`: Configurations for nodes created by the platform. The available options are platform-dependent.
-- `image_name_builder`: If this key is specified, platforms will be passed a dynamically generated image name based on the configurations under this key.
-
-### Semantic acceptance test names
-
-With CemAcpt, acceptance test names can have semantic meaning and influence how your acceptance test nodes are provisioned and how test data is created. The semantic meaning of the test names can be configured in the config file.
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/cem_acpt/context.rb

@@ -36,10 +36,8 @@ module CemAcpt
       # Creates a SSH key and a SSH known hosts file for the acceptance test suite
       def new_test_ssh_key
         log('Creating ephemeral SSH key and known hosts file for acceptance test suites...')
-        @ssh_priv_key, @ssh_pub_key = CemAcpt::Utils::SSH.ephemeral_ssh_key
-        @ssh_known_hosts = CemAcpt::Utils::SSH.acpt_known_hosts
-        CemAcpt::Utils::SSH.set_ssh_file_permissions(@ssh_priv_key, @ssh_pub_key, @ssh_known_hosts)
-        log('Successfully created SSH files...')
+        @ssh_priv_key, @ssh_pub_key, @ssh_known_hosts = CemAcpt::Utils::SSH::Ephemeral.create
+        log('Successfully created SSH files.')
         log("SSH private key: #{@ssh_priv_key}", :debug)
         log("SSH public key: #{@ssh_pub_key}", :debug)
         log("SSH known hosts: #{@ssh_known_hosts}", :debug)
@@ -48,7 +46,9 @@ module CemAcpt
       # Deletes acceptance test suite SSH files
       def clean_test_ssh_key
         log('Deleting ephemeral ssh keys and acpt_known_hosts if they exist...')
-        [@ssh_priv_key, @ssh_pub_key, @ssh_known_hosts].map { |f| File.delete(f) if File.exist?(f) }
+        cleaned = CemAcpt::Utils::SSH::Ephemeral.clean
+        log('Successfully cleaned ephemeral ssh files.')
+        log("Deleted: #{cleaned}", :debug)
       end
 
       # Prints a period to the terminal every 5 seconds in a single line to keep the terminal
@@ -62,8 +62,8 @@ module CemAcpt
       end
 
       def clean_up_test_suite(opts)
-        @ctx.node_inventory.clear!
-        @ctx.node_inventory.clean_local_files
+        @ctx&.node_inventory&.clear!
+        @ctx&.node_inventory&.clean_local_files
         clean_test_ssh_key unless opts[:no_ephemeral_ssh_key]
         @run_handler&.destroy_test_nodes
         @keep_terminal_alive&.kill

data/lib/cem_acpt/logging/formatter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module Logging
+    module Formatter
+      class << self
+        def for(log_format)
+          all.find { |f| f.log_format == log_format.downcase.to_sym }.get
+        end
+
+        private
+
+        def all
+          @all ||= [FileFormatter.new, JSONFormatter.new, TextFormatter.new, GithubActionFormatter.new]
+        end
+      end      
+
+      class FileFormatter
+        attr_reader :log_format
+
+        def initialize
+          @log_format = :file
+        end
+  
+        def get
+          proc do |severity, datetime, progname, msg|
+            format(severity, datetime, progname, msg)
+          end
+        end
+
+        private
+
+        def format(severity, datetime, _progname, msg)
+          "[#{datetime}] #{severity}: #{msg}\n"
+        end
+      end
+
+      class JSONFormatter < FileFormatter
+        def initialize
+          super
+          @log_format = :json
+        end
+
+        private
+
+        def format(severity, datetime, progname, msg)
+          require 'json'
+          {
+            timestamp: datetime,
+            progname: progname,
+            severity: severity,
+            message: msg,
+          }.to_json + "\n"
+        end
+      end
+
+      class TextFormatter < FileFormatter
+        def initialize
+          super
+          @log_format = :text
+        end
+
+        private
+
+        def format(severity, _datetime, _progname, msg)
+          "#{severity} - #{msg}\n"
+        end
+      end
+
+      class GithubActionFormatter < FileFormatter
+        SEV_MAP = {
+          'DEBUG' => '::debug',
+          'INFO' => '::notice',
+          'WARN' => '::warning',
+          'ERROR' => '::error',
+          'FATAL' => '::error',
+        }.freeze
+
+        def initialize
+          super
+          @log_format = :github_action
+        end
+
+        private
+
+        def format(severity, _datetime, _progname, msg)
+          if severity == 'DEBUG'
+            "#{SEV_MAP[severity]}::{#{msg}}\n"
+          else
+            "#{SEV_MAP[severity]} #{msg}\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/logging.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'logger'
+require 'cem_acpt/logging/formatter'
 
 module CemAcpt
   # Logging for CemAcpt
@@ -92,41 +93,7 @@ module CemAcpt
       # @param f [Symbol] the log format style to set
       # @return [Proc] the proc to be passed to Logger#formatter=
       def new_log_formatter(f)
-        case f.downcase.to_sym
-        when :json
-          require 'json'
-          @current_log_format = :json
-          proc do |severity, datetime, progname, msg|
-            {
-              timestamp: datetime,
-              progname: progname,
-              severity: severity,
-              message: msg,
-            }.to_json + "\n"
-          end
-        when :text
-          @current_log_format = :text
-          proc do |severity, _datetime, _progname, msg|
-            "#{severity} - #{msg}\n"
-          end
-        when :github_action
-          @current_log_format = :github_action
-          sev_map = {
-            'DEBUG' => '::debug::',
-            'INFO' => '::notice::',
-            'WARN' => '::warning::',
-            'ERROR' => '::error::',
-            'FATAL' => '::error::',
-          }
-          proc do |severity, _datetime, _progname, msg|
-            "#{sev_map[severity]}{#{msg}}\n"
-          end
-        else
-          @current_log_format = :file
-          proc do |severity, datetime, _progname, msg|
-            "[#{datetime}] #{severity}: #{msg}\n"
-          end
-        end
+        CemAcpt::Logging::Formatter.for(f)
       end
 
       # Returns the current log config if set, or the default if not.

data/lib/cem_acpt/rspec_utils.rb

@@ -12,13 +12,17 @@ module CemAcpt
     class BundlerNotFoundError < StandardError; end
     class RSpecNotFoundError < StandardError; end
 
-    # Holds and formats a RSpec command
-    class Command
-      include CemAcpt::LoggingAsync
-      attr_reader :debug, :format, :test_path, :use_bundler, :pty_pid
+    # Holds RSpec options used by Command
+    class Options
+      OPTIONS = %i[test_path bundle rspec use_bundler bundle_install format debug quiet env].freeze
 
+      attr_accessor(*OPTIONS)
+
+      # @param config [CemAcpt::Config] A config object
       # @param opts [Hash] options hash for the RSpec command
       # @option opts [String] :test_path The path (or glob path) to the test file(s) to run. If blank, runs all.
+      # @option opts [String] :bundle The path to the `bundle` binary.
+      # @option opts [String] :rspec The path to the `rspec` binary.
       # @option opts [Hash] :format Format options for rspec where the key is the format (documentation, json, etc)
       #   and the value is the out-file path. If you do not want to save the results of a format to a file, the
       #   value should be `nil`.
@@ -30,56 +34,97 @@ module CemAcpt
       #   Default is `true`.
       # @option opts [Boolean] :bundle_install Whether or not to run `bundle install` before the RSpec command
       #   if `use_bundler` is `true`.
-      # @option opts [Boolean] :use_shell Whether or not to add `$SHELL` as a prefix to the command
       # @option opts [Hash] :env Environment variables to prepend to the command
-      def initialize(opts = {})
-        @test_path = opts[:test_path]&.shellescape
-        @format = opts.fetch(:format, {})
-        @debug = opts.fetch(:debug, false)
-        @quiet = @debug ? false : opts.fetch(:quiet, false)
-        @use_bundler = opts.fetch(:use_bundler, false)
-        @bundle_install = opts.fetch(:bundle_install, false)
-        @env = opts.fetch(:env, {})
-        @pty_pid = nil
-        validate_and_set_bin_paths(opts)
+      def initialize(config, **opts)
+        @config = config
+        @opts = opts
+        define_option_instance_vars
+      end
+
+      # Finds and sets the paths to the `bundle` and `rspec` binaries. The paths can
+      # be either passed in as options in the `opts` Hash or interrogated from the
+      # system.
+      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
+      #   `bundle` binary is not found.
+      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
+      def resolve_bin_paths
+        %i[bundle rspec].each do |bin|
+          bin_path = instance_variable_get("@#{bin}") || `#{ENV['SHELL']} -c 'command -v #{bin}'`.strip
+          bin_not_found(bin, bin_path) unless bin_path && File.exist?(bin_path)
+          instance_variable_set("@#{bin}", bin_path)
+        end
+      end
+
+      # Detects if the current Ruby context is JRuby
+      def jruby?
+        Object.const_defined?('JRUBY_VERSION')
       end
 
-      # Sets debug mode to `true`
-      def set_debug
-        @debug = true
-        if @quiet
-          async_debug('Setting :quiet to false because :debug is now true.')
-          @quiet = false
+      private
+
+      def defaults
+        @defaults ||= { use_bundler: false,
+                        bundle_install: false,
+                        format: { documentation: nil },
+                        debug: false,
+                        quiet: false,
+                        env: {} }
+      end
+
+      def define_option_instance_vars
+        OPTIONS.each do |o|
+          val = @config.get("rspec.#{o}") || @opts[o] || defaults[o] || nil
+          instance_variable_set("@#{o}", val)
         end
       end
 
-      # Sets debug mode to `false`
-      def unset_debug
-        @debug = false
+      # Handles binary paths which are not found
+      # @param bin [Symbol] The binary that was not found, either :bundle or :rspec.
+      # @param bin_path [String] The path to the binary that was checked.
+      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
+      #   `bundle` binary is not found.
+      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
+      # @raise [RuntimeError] if `bin` is not :bundle or :rspec.
+      def bin_not_found(bin, bin_path)
+        msg_base = "#{bin} not found."
+        msg = bin_path.nil? ? "#{msg_base} Path is nil." : "#{msg_base} Path: #{bin_path}"
+        case bin
+        when :bundle
+          raise BundlerNotFoundError, msg if opts.use_bundler
+        when :rspec
+          raise RSpecNotFoundError, msg
+        else
+          raise "bin #{bin} not recognized!"
+        end
       end
+    end
+
+    # Holds and formats a RSpec command
+    class Command
+      include CemAcpt::LoggingAsync
+      attr_reader :opts, :pty_pid
+
+      def initialize(opts = Options.new)
+        raise 'opts must be instance of CemAcpt::RSpecUtils::Options' unless opts.is_a?(CemAcpt::RSpecUtils::Options)
 
-      def quiet
-        @quiet && !debug
+        @opts = opts
+        @opts.resolve_bin_paths
+        @opts.env = @opts.env.merge({ 'RSPEC_DEBUG' => 'true' }) if @opts.debug
+        @pty_pid = nil
       end
 
       # Adds a new format to the RSpec command
       # @param fmt [String] The name of the format (i.e. "documentation", "json", etc.)
       # @param out [String] If specified, saves the specified format to a file at this path
       def with_format(fmt, out: nil)
-        @format[fmt.to_sym] = out
-      end
-
-      # Environment variables that will be used for the RSpec command
-      # @return [Hash] A Hash of environment variables with each key pair being: <var name> => <var value>
-      def env
-        @debug ? @env.merge({ 'RSPEC_DEBUG' => 'true' }) : @env
+        opts.format[fmt.to_sym] = out
       end
 
       # Returns an array representation of the RSpec command
       def to_a
         cmd = cmd_base.dup
-        cmd << test_path if test_path
-        format.each do |fmt, out|
+        cmd << opts.test_path if opts.test_path
+        opts.format.each do |fmt, out|
           cmd += ['--format', fmt.to_s.shellescape]
           cmd += ['--out', out.to_s.shellescape] if out
         end
@@ -112,12 +157,12 @@ module CemAcpt
       # @return [Integer] The exit code of the RSpec command
       def execute_pty(log_prefix: 'RSPEC')
         async_debug("Executing RSpec command '#{self}' in PTY...", log_prefix)
-        PTY.spawn(env, ENV['SHELL']) do |r, w, pid|
+        PTY.spawn(opts.env, ENV['SHELL']) do |r, w, pid|
           @pty_pid = pid
           async_debug("Spawned RSpec PTY with PID #{@pty_pid}", log_prefix)
           export_envs(w)
           w.puts "#{self}; exit $?"
-          quiet ? wait_io(r) : read_io(r, log_prefix: log_prefix)
+          handle_io(r, log_prefix: log_prefix)
         end
         $CHILD_STATUS
       end
@@ -130,9 +175,9 @@ module CemAcpt
       def execute_no_pty(log_prefix: 'RSPEC')
         async_info("Executing RSpec command '#{self}' with Open3.popen2e()...", log_prefix)
         exit_status = nil
-        Open3.popen2e(env, to_s) do |stdin, std_out_err, wait_thr|
+        Open3.popen2e(opts.env, to_s) do |stdin, std_out_err, wait_thr|
           stdin.close
-          quiet ? wait_io(std_out_err) : read_io(std_out_err, log_prefix: log_prefix)
+          handle_io(std_out_err, log_prefix: log_prefix)
           exit_status = wait_thr.value
         end
         exit_status
@@ -147,26 +192,21 @@ module CemAcpt
 
       private
 
-      # Detects if the current Ruby context is JRuby
-      def jruby?
-        File.basename(RbConfig.ruby) == 'jruby'
-      end
-
       # The base RSpec command
       def cmd_base
-        use_bundler ? cmd_base_bundler : cmd_base_rspec
+        opts.use_bundler ? cmd_base_bundler : cmd_base_rspec
       end
 
       # The base RSpec command if `:use_bundler` is `true`.
       def cmd_base_bundler
-        base = [@bundle, 'exec', 'rspec']
-        base.unshift("#{@bundle} install;") if @bundle_install
+        base = [opts.bundle, 'exec', 'rspec']
+        base.unshift("#{opts.bundle} install;") if opts.bundle_install
         base
       end
 
       # The base RSpec command if `:use_bundler` is `false`
       def cmd_base_rspec
-        [@rspec]
+        [opts.rspec]
       end
 
       # Puts export statements for each key-value pair in `env` to the given writer.
@@ -174,46 +214,14 @@ module CemAcpt
       # pass the statements to a shell.
       # @param writer [IO] An IO object that supprts `puts` and can send statements to a shell
       def export_envs(writer)
-        env.each do |key, val|
+        @opts.env.each do |key, val|
           writer.puts "export #{key}=#{val}"
         end
       end
 
-      # Finds and sets the paths to the `bundle` and `rspec` binaries. The paths can
-      # be either passed in as options in the `opts` Hash or interrogated from the
-      # system.
-      # @param opts [Hash] The options hash
-      # @option opts [String] :bundle An absolute path on the system to the `bundle` binary.
-      # @option opts [String] :rspec An absolute path on the system to the `rspec` binary.
-      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
-      #   `bundle` binary is not found.
-      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
-      def validate_and_set_bin_paths(opts = {})
-        %i[bundle rspec].each do |bin|
-          bin_path = opts[bin] || `command -v #{bin}`.strip
-          bin_not_found(bin, bin_path) unless bin_path && File.exist?(bin_path)
-          instance_variable_set("@#{bin}", bin_path)
-        end
-      end
-
-      # Handles binary paths which are not found
-      # @param bin [Symbol] The binary that was not found, either :bundle or :rspec.
-      # @param bin_path [String] The path to the binary that was checked.
-      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
-      #   `bundle` binary is not found.
-      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
-      # @raise [RuntimeError] if `bin` is not :bundle or :rspec.
-      def bin_not_found(bin, bin_path)
-        msg_base = "#{bin} not found."
-        msg = bin_path.nil? ? "#{msg_base} Path is nil." : "#{msg_base} Path: #{bin_path}"
-        case bin
-        when :bundle
-          raise BundlerNotFoundError, msg if @use_bundler
-        when :rspec
-          raise RSpecNotFoundError, msg
-        else
-          raise "bin #{bin} not recognized!"
-        end
+      # Handles IO output
+      def handle_io(io_stream, **kwargs)
+        opts.quiet ? wait_io(io_stream) : read_io(io_stream, log_prefix: kwargs[:log_prefix])
       end
 
       # Blocking wait on an IO stream. Wait stops once the IO stream has reached

data/lib/cem_acpt/test_runner/run_handler.rb

@@ -105,10 +105,7 @@ module CemAcpt
             if result['examples'].empty? && !result['messages'].empty?
               logger.error(result['messages'].join("\n"))
             else
-              failed = result['examples'].reject { |e| e['status'] == 'passed' }
-              failed.each do |e|
-                logger.error(test_error_msg(runner.node.node_name, e))
-              end
+              handle_example_error_pending_skipped(runner.node.node_name, result['examples'])
             end
           else
             handle_runner_error_results(runner)
@@ -118,6 +115,19 @@ module CemAcpt
         end
       end
 
+      # Handles logging for any failed / skipped / pending examples.
+      def handle_example_error_pending_skipped(node_name, examples)
+        examples.each do |e|
+          next if e['status'] == 'passed'
+
+          if e['status'] == 'pending'
+            logger.info(test_pending_msg(node_name, e))
+          else
+            logger.error(test_error_msg(node_name, e))
+          end
+        end
+      end
+
       # Handles logging the results of the runners that errored.
       def handle_runner_error_results(runner)
         logger.error("SUMMARY: Encountered an error with test #{runner.node.test_data[:test_name]} on node #{runner.node.node_name}")
@@ -136,6 +146,19 @@ module CemAcpt
           "Error: #{err.message}",
           'Backtrace:',
           err.backtrace.join("\n"),
+          "\n",
+        ].join("\n")
+      end
+
+      # Formats a test result for tests that are pending or skipped. Is used for logging.
+      # @param node [String] the name of the node the test ran on
+      # @param result [Hash] the test result to format
+      # @return [String] the formatted test result
+      def test_pending_msg(_, result)
+        [
+          "TEST PENDING / SKIPPED: #{result['full_description']}",
+          "REASON: #{result['pending_message']}",
+          "\n",
         ].join("\n")
       end
 

data/lib/cem_acpt/test_runner/runner.rb

@@ -145,12 +145,12 @@ module CemAcpt
         async_info("Running test #{@node.test_data[:test_name]} on node #{@node.node_name}...", log_prefix('RSPEC'))
         @node.run_tests do |cmd_env|
           cmd_opts = rspec_opts
-          cmd_opts[:env].merge!(cmd_env) if cmd_env
+          cmd_opts.env = cmd_opts.env.merge(cmd_env) if cmd_env
           # Documentation format gets logged in real time, JSON file is read after the fact
           begin
             @rspec_cmd = CemAcpt::RSpecUtils::Command.new(cmd_opts)
-            @rspec_cmd.execute(log_prefix: log_prefix('RSPEC'))
-            @run_result.from_json_file(cmd_opts[:format][:json])
+            @rspec_cmd.execute(pty: false, log_prefix: log_prefix('RSPEC'))
+            @run_result.from_json_file(cmd_opts.format[:json])
           rescue Errno::EIO => e
             async_error("failed to run rspec: #{@node.test_data[:test_name]}: #{$ERROR_INFO}", log_prefix('RSPEC'))
             @run_result.from_error(e)
@@ -191,19 +191,21 @@ module CemAcpt
 
       # Options used with RSpec
       def rspec_opts
-        opts = {
-          test_path: @node.test_data[:test_file],
-          use_bundler: @context.config.get('rspec.use_bundler') || false,
-          bundle_install: @context.config.get('rspec.bundle_install') || false,
-          format: @context.config.get('rspec.format') || { json: "results_#{@node.test_data[:test_name]}.json" },
-          debug: (@debug_mode && @context.config.get('verbose')),
-          quiet: @context.config.get('quiet'),
-          env: {
-            'TARGET_HOST' => @node.node_name,
-          }
-        }
-        opts[:format][:documentation] = nil unless @context.config.get('verbose') || @context.config.get('rspec.format')
-        opts
+        opts_test_path = @node.test_data[:test_file]
+        opts_env = { 'TARGET_HOST' => @node.node_name }
+        opts_debug = (@debug_mode && @context.config.get('verbose'))
+        opts_quiet = @context.config.get('quiet')
+        opts_format = if @context.config.get('verbose')
+                        { json: "results_#{@node.test_data[:test_name]}.json", documentation: nil }
+                      else
+                        { json: "results_#{@node.test_data[:test_name]}.json" }
+                      end
+        CemAcpt::RSpecUtils::Options.new(@context.config,
+                                         test_path: opts_test_path,
+                                         env: opts_env,
+                                         debug: opts_debug,
+                                         quiet: opts_quiet,
+                                         format: opts_format)
       end
     end
   end

data/lib/cem_acpt/utils.rb

@@ -81,6 +81,40 @@ module CemAcpt
 
     # SSH-related utilities
     module SSH
+      module Ephemeral
+        PRIV_KEY = 'acpt_test_key'
+        CREATE_OPTS = {
+          type: 'rsa',
+          bits: '4096',
+          comment: 'Ephemeral for cem_acpt',
+          password: '',
+          known_hosts: 'acpt_known_hosts',
+          overwrite_known_hosts: true,
+        }.freeze
+
+        class << self
+          attr_accessor :ephemeral_keydir
+        end
+
+        def self.create(keydir: CemAcpt::Utils::SSH.default_keydir)
+          self.ephemeral_keydir = keydir
+          @priv_key, @pub_key, @known_hosts = CemAcpt::Utils::SSH.create(PRIV_KEY, keydir: ephemeral_keydir, **CREATE_OPTS)
+          [@priv_key, @pub_key, @known_hosts]
+        end
+
+        def self.clean
+          [@priv_key, @pub_key, @known_hosts].each_with_object([]) do |f, arr|
+            next unless f
+
+            path = CemAcpt::Utils::SSH.file_path(f, keydir: ephemeral_keydir)
+            if ::File.exist?(path)
+              ::File.delete(path)
+              arr << path
+            end
+          end
+        end
+      end
+
       def self.ssh_keygen
         bin_path = `#{ENV['SHELL']} -c 'command -v ssh-keygen'`.chomp
         raise 'Cannot find ssh-keygen! Install it and verify PATH' unless bin_path
@@ -97,26 +131,52 @@ module CemAcpt
         ssh_dir
       end
 
-      def self.ephemeral_ssh_key(type: 'rsa', bits: '4096', comment: nil, keydir: default_keydir)
-        raise ArgumentError, 'keydir does not exist' unless ::File.directory?(keydir)
+      def self.file_path(file_name, keydir: default_keydir)
+        ::File.join(keydir, file_name)
+      end
+
+      # Takes a file name (not path) and optional SSH key directory and returns the paths
+      # to the private key and public key based on the file name given.
+      # @param file_name [String] The base name for the keys
+      # @param keydir [String] An optional SSH key directory
+      def self.key_paths(file_name, keydir: default_keydir)
+        [file_path(file_name, keydir: keydir), file_path("#{file_name}.pub", keydir: keydir)]
+      end
 
-        keyfile = ::File.join(keydir, 'acpt_test_key')
-        keygen_cmd = [ssh_keygen, "-t #{type}", "-b #{bits}", "-f #{keyfile}", '-N ""']
+      def self.create(key_name, type: 'rsa', bits: '4096', comment: nil, password: '', known_hosts: nil, overwrite_known_hosts: true, keydir: default_keydir)
+        raise ArgumentError, "Key directory #{keydir} does not exist" unless ::File.directory?(keydir)
+
+        keys = key_paths(key_name, keydir: keydir)
+        # If we don't delete an existing key file, generation will fail
+        keys.each { |f| ::File.delete(f) if ::File.exist?(f) }
+        keygen_cmd = [ssh_keygen, "-t #{type}", "-b #{bits}", "-f #{keys[0]}", "-N '#{password}'"]
         keygen_cmd << "-C \"#{comment}\"" if comment
         _, stderr, status = Open3.capture3(keygen_cmd.join(' '))
-        raise "Failed to generate ephemeral SSH key: #{stderr}" unless status.success?
+        raise "Failed to generate ephemeral SSH key: STDOUT: #{stdout}; STDERR: #{stderr}" unless status.success?
 
-        [keyfile, "#{keyfile}.pub"]
+        keys << create_known_hosts(known_hosts, overwrite: overwrite_known_hosts, keydir: keydir)
+        set_ssh_file_permissions(*keys)
+        keys
       end
 
-      def self.acpt_known_hosts(keydir: default_keydir, file_name: 'acpt_known_hosts', overwrite: true)
-        kh_file = ::File.join(keydir, file_name)
+      def self.create_known_hosts(known_hosts, overwrite: true, keydir: default_keydir)
+        return nil unless known_hosts
+
+        kh_file = file_path(known_hosts, keydir: keydir)
         ::File.open(kh_file, 'w') { |f| f.write("\n") } unless ::File.exist?(kh_file) && !overwrite
         kh_file
       end
 
-      def self.set_ssh_file_permissions(priv_key, pub_key, known_hosts)
-        CemAcpt::Utils::File.set_permissions(0o600, priv_key, pub_key, known_hosts)
+      def self.set_ssh_file_permissions(*files)
+        CemAcpt::Utils::File.set_permissions(0o600, *files.uniq.compact)
+      end
+
+      def self.ephemeral_ssh_key(keydir: default_keydir)
+        CemAcpt::Utils::SSH::Ephemeral.create(keydir: keydir)
+      end
+
+      def self.clean_ephemeral_keys
+        CemAcpt::Utils::SSH::Ephemeral.clean
       end
     end
 

data/lib/cem_acpt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cem_acpt
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.11
 platform: universal-java-17
 authors:
 - puppetlabs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-28 00:00:00.000000000 Z
+date: 2022-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -160,6 +160,7 @@ files:
 - lib/cem_acpt/core_extensions.rb
 - lib/cem_acpt/image_name_builder.rb
 - lib/cem_acpt/logging.rb
+- lib/cem_acpt/logging/formatter.rb
 - lib/cem_acpt/platform.rb
 - lib/cem_acpt/platform/base.rb
 - lib/cem_acpt/platform/base/cmd.rb