cem_acpt 0.2.5 → 0.6.1

data/lib/cem_acpt/test_data.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'pathname'
 require_relative 'core_extensions'
 require_relative 'logging'
 
@@ -19,28 +20,38 @@ module CemAcpt
       include CemAcpt::Logging
       using CemAcpt::CoreExtensions::ExtendedHash
 
-      attr_reader :module_dir, :acceptance_tests
+      attr_reader :acpt_test_dir, :acceptance_tests
 
       # Initializes a new Fetcher object.
       # @param config [CemAcpt::Config] the config object
       def initialize(config)
         @config = config
-        @module_dir = config.get('module_dir')
-        @acceptance_tests = find_acceptance_tests(config.get('module_dir'))
+        @acpt_test_dir = Pathname(File.join(@config.get('module_dir'), 'spec', 'acceptance'))
+        find_acceptance_tests!
       end
 
       # Extracts, formats, and returns a test data hash.
       # @return [Array<Hash>] an array of test data hashes
       def acceptance_test_data
         logger.info 'Gathering acceptance test data...'
-        acceptance_tests.each_with_object([]) do |t, a|
-          logger.debug("Processing #{t}...")
-          test_name = File.basename(t, '_spec.rb')
+        raise "No 'tests' entry found in config" unless @config.has?('tests')
+
+        @config.get('tests').each_with_object([]) do |test_name, a|
+          test_dir = acceptance_tests.find { |f| File.basename(f) == test_name }
+          raise "Test directory not found for test #{test_name}" unless test_dir
+
+          goss_file = File.expand_path(File.join(test_dir, 'goss.yaml'))
+          puppet_manifest = File.expand_path(File.join(test_dir, 'manifest.pp'))
+          raise "Goss file not found for test #{test_name}" unless File.exist?(goss_file)
+          raise "Puppet manifest not found for test #{test_name}" unless File.exist?(puppet_manifest)
+
+          logger.debug("Complete test directory found for test #{test_name}: #{test_dir}")
           test_data = {
             test_name: test_name,
-            test_file: File.expand_path(t),
+            test_dir: File.expand_path(test_dir),
+            goss_file: goss_file,
+            puppet_manifest: puppet_manifest,
           }
-          next unless @config.has?('tests') && @config.get('tests').include?(test_name)
 
           process_for_each(test_data).each do |test_data_i|
             process_static_vars(test_data_i)
@@ -56,12 +67,11 @@ module CemAcpt
 
       # Locates acceptance tests in the module directory.
       # @return [Array<String>] the list of acceptance test paths
-      def find_acceptance_tests(module_dir)
-        tests = Dir.glob(File.join(module_dir, 'spec', 'acceptance', '*_spec.rb'))
-        raise 'No acceptance tests found' if tests.empty?
+      def find_acceptance_tests!
+        @acceptance_tests = acpt_test_dir.children.select { |f| f.directory? && File.exist?(File.join(f, 'goss.yaml')) }.map(&:to_s)
+        raise 'No acceptance tests found' if @acceptance_tests.empty?
 
-        logger.info "Found #{tests.size} acceptance tests"
-        tests
+        logger.info "Found #{@acceptance_tests.size} acceptance tests"
       end
 
       # Processes a for_each statement in the test data config.

data/lib/cem_acpt/test_runner/log_formatter/goss_action_response.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      # Formats the results of a Goss action
+      class GossActionResponse
+        INDENT = '  '
+
+        def initialize(config, instance_names_ips)
+          @config = config
+          @instance_names_ips = instance_names_ips
+        end
+
+        def inspect
+          to_s
+        end
+
+        def to_s
+          "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+        end
+
+        def summary(response)
+          new_summary_message(response)
+        end
+
+        def results(response)
+          new_results_message(response.results)
+        end
+
+        def host_name(response)
+          name_from_ip(response.host)
+        end
+
+        def test_name(response)
+          test_from_ip(response.host)
+        end
+
+        private
+
+        def normalize_whitespace(str)
+          raise ArgumentError, 'str must be a String' unless str.is_a?(String)
+
+          str.gsub(%r{(\n|\r|\t)}, ' ').gsub(%r{\s{2,}}, ' ').strip
+        end
+
+        def success_str(success)
+          success ? 'passed' : 'failed'
+        end
+
+        def name_from_ip(ip)
+          @instance_names_ips.each do |name, val|
+            return name if val['ip'] == ip
+          end
+          ip
+        end
+
+        def test_from_ip(ip)
+          @instance_names_ips.each do |_name, val|
+            return val['test_name'] if val['ip'] == ip
+          end
+          '<unknown>'
+        end
+
+        def new_summary_message(response)
+          msg = [
+            "SUMMARY: #{success_str(response.success?).capitalize}: Test #{test_from_ip(response.host)}:",
+            "#{normalize_whitespace(response.summary.summary_line)}:",
+            "Action '#{response.action}' on host #{name_from_ip(response.host)}",
+          ].join(' ')
+          return msg unless @config.debug?
+
+          [
+            msg,
+            "HTTP Status: #{response.http_status}",
+            "Failed percentage: #{response.summary.failed_percentage}",
+          ].join("\n#{INDENT}")
+        end
+
+        def new_results_message(results)
+          results.map { |r| new_result_message(r) }
+        end
+
+        def new_result_message(result)
+          return "Error: #{result.error}" unless result.err.nil?
+
+          status = result.skipped? ? 'Skipped' : success_str(result.success?).capitalize
+          msg = [
+            "#{status}:",
+            normalize_whitespace(result.summary_line),
+          ]
+          return msg.join(' ') unless @config.debug?
+
+          [
+            msg.join(' '),
+            "Duration: #{result.duration.to_s}",
+            "Expected: #{result.expected}",
+            "Found: #{result.found}",
+          ].join("\n#{INDENT}")
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/test_runner/log_formatter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'log_formatter/goss_action_response'
+
+module CemAcpt
+  module TestRunner
+    # Holds classes for formatting test runner results
+    module LogFormatter; end
+  end
+end

data/lib/cem_acpt/test_runner.rb

@@ -1,10 +1,177 @@
 # frozen_string_literal: true
 
+require_relative 'core_extensions'
+require_relative 'goss'
+require_relative 'logging'
+require_relative 'platform'
+require_relative 'provision'
+require_relative 'test_data'
+require_relative 'utils'
+require_relative 'version'
+require_relative 'test_runner/log_formatter'
+
 module CemAcpt
   # Namespace for all Runner-related classes and modules
   module TestRunner
-    require_relative 'test_runner/run_handler'
-    require_relative 'test_runner/runner'
-    require_relative 'test_runner/runner_result'
+    # Holds all the Runner related code
+    class Runner
+      include CemAcpt::Logging
+
+      attr_reader :duration, :exit_code
+
+      def initialize(config)
+        @config = config
+        @run_data = {}
+        @duration = 0
+        @exit_code = 0
+        @results = nil
+        @http_statuses = []
+      end
+
+      def inspect
+        to_s
+      end
+
+      def to_s
+        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+      end
+
+      def run
+        @run_data = {}
+        @start_time = Time.now
+        logger.info('CemAcpt') { "Starting CemAcpt v#{CemAcpt::VERSION}..." }
+        logger.info('CemAcpt') { "Test suite started at #{@start_time}..." }
+        logger.info('CemAcpt') { "Using module directory: #{config.get('module_dir')}..." }
+        Dir.chdir(config.get('module_dir')) do
+          keep_terminal_alive
+          @run_data[:priv_key], @run_data[:pub_key], @run_data[:known_hosts] = new_ephemeral_ssh_keys
+          logger.info('CemAcpt') { 'Created ephemeral SSH key pair...' }
+          @run_data[:module_package_path] = build_module_package
+          logger.info('CemAcpt') { "Created module package: #{@run_data[:module_package_path]}..." }
+          @run_data[:test_data] = new_test_data
+          logger.info('CemAcpt') { 'Created test data...' }
+          logger.verbose('CemAcpt') { "Test data: #{@run_data[:test_data]}" }
+          @run_data[:nodes] = new_node_data
+          logger.info('CemAcpt') { 'Created node data...' }
+          logger.verbose('CemAcpt') { "Node data: #{@run_data[:nodes]}" }
+          @instance_names_ips = provision_test_nodes
+          logger.info('CemAcpt') { 'Provisioned test nodes...' }
+          logger.debug('CemAcpt') { "Instance names and IPs: #{@instance_names_ips}" }
+          @results = run_tests(@instance_names_ips.map { |_, v| v['ip'] },
+                               config.get('actions.only'),
+                               config.get('actions.except'))
+        end
+      ensure
+        clean_up
+        process_test_results
+      end
+
+      def clean_up(trap_context = false)
+        unless trap_context
+          kill_keep_terminal_alive
+        end
+        clean_ephemeral_ssh_keys
+        destroy_test_nodes
+      end
+
+      private
+
+      attr_reader :config
+
+      # @return [Thread] The thread that keeps the terminal alive
+      def keep_terminal_alive
+        return unless config.ci?
+
+        @keep_terminal_alive ||= CemAcpt::Utils::Terminal.keep_terminal_alive
+      end
+
+      def kill_keep_terminal_alive
+        return if @trap_context
+
+        keep_terminal_alive&.kill
+      end
+
+      # @return [String] The path to the module package
+      def build_module_package
+        CemAcpt::Utils::Puppet.build_module_package(config.get('module_dir'))
+      end
+
+      # @return [Array<String>] The paths to the ssh private key, public key, and known hosts file
+      def new_ephemeral_ssh_keys
+        return [nil, nil, nil] if config.get('no_ephemeral_ssh_key')
+
+        CemAcpt::Utils::SSH::Ephemeral.create
+      end
+
+      def clean_ephemeral_ssh_keys
+        return if config.get('no_ephemeral_ssh_key')
+
+        CemAcpt::Utils::SSH::Ephemeral.clean
+      end
+
+      def new_test_data
+        CemAcpt::TestData.acceptance_test_data(config)
+      end
+
+      def new_node_data
+        CemAcpt::Platform.use(config.get('platform.name'), config, @run_data[:test_data])
+      end
+
+      def provision_test_nodes
+        @provisioner = CemAcpt::Provision.new_provisioner(config, @run_data)
+        @provisioner.provision
+      end
+
+      def destroy_test_nodes
+        @provisioner&.destroy
+      end
+
+      def run_tests(hosts, only_actions, except_actions)
+        only_actions = [] if only_actions.nil?
+        except_actions = [] if except_actions.nil?
+        CemAcpt::Goss::Api.run_actions_async(hosts, only: only_actions, except: except_actions)
+      end
+
+      def result_log_formatter
+        @result_log_formatter ||= LogFormatter::GossActionResponse.new(config, @instance_names_ips)
+      end
+
+      def process_test_results
+        if @results.nil?
+          logger.error('CemAcpt') { 'No test results to process' }
+          @exit_code = 1
+        else
+          until @results.empty?
+            result = @results.pop
+            @http_statuses << result.http_status
+            log_test_result(result)
+          end
+          if @http_statuses.empty?
+            logger.error('CemAcpt') { 'No test results to process' }
+            @exit_code = 1
+          else
+            @exit_code = @http_statuses.any? { |s| s.to_i != 200 } ? 1 : 0
+          end
+        end
+        @duration = Time.now - @start_time
+        logger.info('CemAcpt') { "Test suite finished after ~#{duration.round} seconds." }
+      end
+
+      def log_test_result(result)
+        logger.with_ci_group("Test results for #{result_log_formatter.test_name(result)}") do
+          logger.info(result_log_formatter.summary(result))
+          formatted_results = result_log_formatter.results(result)
+          formatted_results.each do |r|
+            if r.start_with?('Passed:')
+              logger.verbose { r }
+            elsif r.start_with?('Skipped:')
+              logger.info { r }
+            else
+              logger.error { r }
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/cem_acpt/utils/puppet.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'puppet/modulebuilder'
+require 'fileutils'
+
+module CemAcpt
+  module Utils
+    # Puppet-related utilities
+    module Puppet
+      # Builds a Puppet module package.
+      # @param module_dir [String] Path to the module directory. If target_dir
+      #   is specified as a relative path, it will be relative to the module dir.
+      # @param target_dir [String] Path to the target directory where the package
+      #   will be built. This defaults to the relative path 'pkg/'.
+      # @param should_log [Boolean] Whether or not to log the build process.
+      # @return [String] Path to the built package.
+      def self.build_module_package(module_dir, target_dir = nil, should_log: false)
+        builder_logger = should_log ? logger : nil
+        builder = ::Puppet::Modulebuilder::Builder.new(::File.expand_path(module_dir), target_dir, builder_logger)
+
+        # Validates module metadata by raising exception if invalid
+        _metadata = builder.metadata
+
+        # Builds the module package
+        builder.build
+      end
+    end
+  end
+end

data/lib/cem_acpt/utils/ssh.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'open3'
+require_relative '../logging'
+
+module CemAcpt
+  module Utils
+    # SSH-related utilities
+    module SSH
+      # Class for generating SSH keys
+      class Keygen
+        include CemAcpt::Logging
+
+        DEFAULT_TYPE = 'ed25519'
+        DEFAULT_PASSPHRASE = ''
+        DEFAULT_ROUNDS = 100
+        DEFAULT_BITS = 4096
+
+        def initialize(key_dir: ::File.join(ENV['HOME'], '.ssh'))
+          @key_dir = key_dir
+          @bin_path = find_bin_path
+        end
+
+        def exist?(key_name)
+          key_paths(key_name, chmod: false)
+          true
+        rescue StandardError
+          false
+        end
+
+        def create(key_name, **options)
+          delete(key_name) # Delete existing keys with same name
+          cmd = new_keygen_cmd(key_name, **options)
+          logger.debug("Creating SSH key with command: #{cmd}")
+          _stdout, stderr, status = Open3.capture3(cmd)
+          raise "Failed to create SSH key! #{stderr}" unless status.success?
+
+          key_paths(key_name)
+        end
+
+        def delete(key_name)
+          priv_key = key_path(key_name)
+          pub_key = key_path(key_name, public_key: true)
+          if ::File.file?(priv_key)
+            logger.debug("Deleting private key: #{priv_key}")
+            ::File.delete(priv_key)
+          end
+          if ::File.file?(pub_key)
+            logger.debug("Deleting public key: #{pub_key}")
+            ::File.delete(pub_key)
+          end
+        end
+
+        private
+
+        FIND_BIN_PATH_COMMANDS = [
+          "#{ENV['SHELL']} -c 'command -v ssh-keygen'",
+          "#{ENV['SHELL']} -c 'which ssh-keygen'",
+        ].freeze
+
+        def find_bin_path(find_cmd = FIND_BIN_PATH_COMMANDS.first)
+          bin_path, stderr, status = Open3.capture3(find_cmd)
+          raise "Cannot find ssh-keygen with command #{find_cmd}: #{stderr}" unless status.success?
+
+          bin_path.chomp
+        rescue StandardError => e
+          return find_bin_path(FIND_BIN_PATH_COMMANDS.last) unless FIND_BIN_PATH_COMMANDS.last == find_cmd
+
+          raise e
+        end
+
+        def new_keygen_cmd(key_name, **options)
+          [
+            @bin_path,
+            '-o',
+            "-t #{options[:type] || DEFAULT_TYPE}",
+            "-C '#{options[:comment] || "cem_acpt_#{key_name}"}'",
+            "-f #{::File.join(@key_dir, key_name)}",
+            "-N '#{options[:passphrase] || DEFAULT_PASSPHRASE}'",
+            "-a #{options[:rounds] || DEFAULT_ROUNDS}",
+            "-b #{options[:bits] || DEFAULT_BITS}",
+          ].join(' ')
+        end
+
+        def key_path(file_name, public_key: false)
+          key = ::File.join(@key_dir, file_name)
+          public_key ? "#{key}.pub" : key
+        end
+
+        def key_paths(file_name, chmod: true)
+          priv_key = key_path(file_name)
+          pub_key = key_path(file_name, public_key: true)
+          raise "Private key file #{priv_key} does not exist" unless ::File.file?(priv_key)
+          raise "Public key file #{pub_key} does not exist" unless ::File.file?(pub_key)
+
+          ::File.chmod(0o600, priv_key) if chmod
+          ::File.chmod(0o600, pub_key) if chmod
+          [priv_key, pub_key]
+        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
+
+        bin_path
+      rescue StandardError => e
+        raise "Cannot find ssh-keygen! Install it and verify PATH. Orignal error: #{e}"
+      end
+
+      def self.default_keydir
+        ssh_dir = ::File.join(ENV['HOME'], '.ssh')
+        raise "SSH directory at #{ssh_dir} does not exist" unless ::File.directory?(ssh_dir)
+
+        ssh_dir
+      end
+
+      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
+
+      def self.create(key_name, **options)
+        keygen = Keygen.new
+        keys = keygen.create(key_name, **options)
+        keys + ['/dev/null']
+      end
+
+      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(*files)
+        files.uniq.compact.map { |p| ::File.chmod(0o600, p) }
+      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
+
+      # Ephemeral SSH key generation and cleanup
+      module Ephemeral
+        PRIV_KEY = 'acpt_test_key'
+        CREATE_OPTS = {
+          type: 'ed25519',
+          bits: '4096',
+          rounds: '100',
+          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)
+          return [false, false, false] if ENV['CEM_ACPT_SSH_PRI_KEY'] # Don't create ephemeral keys if this is set
+
+          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
+          return if ENV['CEM_ACPT_SSH_PRI_KEY']
+
+          [@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
+    end
+  end
+end

data/lib/cem_acpt/utils/terminal.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+module CemAcpt
+  module Utils
+    # Terminal-related utilities
+    module Terminal
+      def self.keep_terminal_alive
+        executor = Concurrent::SingleThreadExecutor.new
+        executor.post do
+          loop do
+            $stdout.print(".\r")
+            sleep(1)
+            $stdout.print("..\r")
+            sleep(1)
+            $stdout.print("...\r")
+            sleep(1)
+            $stdout.print("   \r")
+            sleep(1)
+          end
+        end
+        executor
+      end
+    end
+  end
+end