cem_acpt 0.2.5 → 0.6.0

data/lib/cem_acpt/provision/terraform.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'ruby-terraform'
+require_relative '../logging'
+require_relative 'terraform/linux'
+require_relative 'terraform/windows'
+
+module CemAcpt
+  module Provision
+    class Terraform
+      DEFAULT_PLAN_NAME = 'testplan.tfplan'
+      include CemAcpt::Logging
+
+      attr_reader :environment, :working_dir
+
+      def initialize(config, provision_data)
+        @config = config
+        @provision_data = provision_data
+        @backend = new_backend(@provision_data[:test_data].first[:test_name])
+        @environment = new_environment(@config)
+        @working_dir = nil
+      end
+
+      def provision
+        logger.info('Terraform') { 'Provisioning nodes...' }
+        @working_dir = new_working_dir
+        validate_working_dir!
+
+        terraform_configure_logging
+        terraform_init
+        terraform_plan(formatted_vars, DEFAULT_PLAN_NAME)
+        terraform_apply(DEFAULT_PLAN_NAME)
+        JSON.parse(terraform_output('instance_name_ip', json: true))
+      end
+
+      def destroy
+        terraform_destroy(formatted_vars)
+        logger.verbose('Terraform') { "Deleting old working directory #{working_dir}" }
+        FileUtils.rm_rf(working_dir)
+        @working_dir = nil
+      end
+
+      private
+
+      def terraform
+        @terraform ||= RubyTerraform
+      end
+
+      def terraform_configure_logging
+        terraform.configure do |c|
+          c.logger = logger
+          c.stdout = c.logger
+          c.stderr = c.logger
+        end
+      end
+
+      def terraform_init
+        logger.debug('Terraform') { 'Initializing Terraform' }
+        terraform.init({ chdir: working_dir, input: false, no_color: true }, { environment: environment })
+      end
+
+      def terraform_plan(vars, plan_name = DEFAULT_PLAN_NAME)
+        logger.debug('Terraform') { "Creating Terraform plan '#{plan_name}'" }
+        logger.verbose('Terraform') { "Using vars:\n#{JSON.pretty_generate(vars)}" }
+        terraform.plan(
+          {
+            chdir: working_dir,
+            input: false,
+            no_color: true,
+            plan: plan_name,
+            vars: vars,
+          },
+          {
+            environment: environment,
+          },
+        )
+      end
+
+      def terraform_apply(plan_name = DEFAULT_PLAN_NAME)
+        logger.debug('Terraform') { "Running Terraform apply with the plan #{plan_name}" }
+        terraform.apply({ chdir: working_dir, input: false, no_color: true, plan: plan_name }, { environment: environment })
+      end
+
+      def terraform_output(name, json: true)
+        logger.debug('Terraform') { "Getting Terraform output #{name}" }
+        terraform.output({ chdir: working_dir, no_color: true, json: json, name: name }, { environment: environment })
+      end
+
+      def terraform_destroy(vars)
+        logger.debug('Terraform') { 'Destroying Terraform resources' }
+        terraform.destroy(
+          {
+            chdir: working_dir,
+            auto_approve: true,
+            input: false,
+            no_color: true,
+            vars: vars,
+          },
+          {
+            environment: environment,
+          },
+        )
+      end
+
+      def new_backend(test_name)
+        if CemAcpt::Provision::Linux.use_for?(test_name)
+          logger.info('Terraform') { 'Using Linux backend' }
+          logger.verbose('Terraform') { "Creating backend with provision_data:\n#{JSON.pretty_generate(@provision_data)}" }
+          CemAcpt::Provision::Linux.new(@config, @provision_data)
+        elsif CemAcpt::Provision::Windows.use_for?(test_name)
+          logger.info('Terraform') { 'Using Windows backend' }
+          logger.verbose('Terraform') { "Creating backend with provision_data:\n#{JSON.pretty_generate(@provision_data)}" }
+          CemAcpt::Provision::Windows.new(@config, @provision_data)
+        else
+          err_msg = [
+            "Test name #{test_name} does not match any known OS.",
+            "Known OSes are: #{CemAcpt::Provision::Linux.valid_names.join(', ')}",
+            "and #{CemAcpt::Provision::Windows.valid_names.join(', ')}.",
+            "Known versions are: #{CemAcpt::Provision::Linux.valid_versions.join(', ')}",
+            ", and #{CemAcpt::Provision::Windows.valid_versions.join(', ')}."
+          ].join(' ')
+          logger.error('Terraform') { err_msg }
+          raise ArgumentError, err_msg
+        end
+      end
+
+      def new_environment(config)
+        env = (config.get('terraform.environment') || {})
+        env['CLOUDSDK_PYTHON_SITEPACKAGES'] = '1' # This is needed for gcloud to use numpy
+        logger.verbose('Terraform') { "Using environment:\n#{JSON.pretty_generate(env)}" }
+        env
+      end
+
+      def new_working_dir
+        logger.debug('Terraform') { "Creating new working directory" }
+        base_dir = File.join(@config.get('terraform.dir'), @config.get('platform.name'))
+        logger.verbose('Terraform') { "Base directory defined as #{base_dir}" }
+        @backend.base_provision_directory = base_dir
+        logger.verbose('Terraform') { 'Base directory set in backend' }
+        work_dir = File.join(@config.get('terraform.dir'), "test_#{Time.now.to_i.to_s}")
+        logger.verbose('Terraform') { "Working directory defined as #{work_dir}" }
+        logger.verbose('Terraform') { "Copying backend provision directory #{@backend.provision_directory} to working directory" }
+        FileUtils.cp_r(@backend.provision_directory, work_dir)
+        logger.verbose('Terraform') { "Copied provision directory #{@backend.provision_directory} to #{work_dir}" }
+        FileUtils.cp(@provision_data[:module_package_path], work_dir)
+        logger.verbose('Terraform') { "Copied module package #{@provision_data[:module_package_path]} to #{work_dir}" }
+        work_dir
+      rescue StandardError => e
+        logger.error('Terraform') { 'Error creating working directory' }
+        raise e
+      end
+
+      def validate_working_dir!
+        logger.debug('Terraform') { "Validating working directory #{working_dir}" }
+        logger.verbose('Terraform') { "Content of #{working_dir}:\n#{Dir.glob(File.join(working_dir, '*')).join("\n")}" }
+        raise "Terraform working directory #{working_dir} does not exist" unless File.directory?(working_dir)
+        raise "Terraform working directory #{working_dir} does not contain a Terraform file" unless Dir.glob(File.join(working_dir, '*.tf')).any?
+        logger.info('Terraform') { "Using working directory: #{working_dir}" }
+      rescue StandardError => e
+        logger.error('Terraform') { 'Error validating working directory' }
+        raise e
+      end
+
+      def provision_node_data
+        node_data = @provision_data[:nodes].each_with_object({}) do |node, h|
+          h[node.node_name] = node.node_data.merge({
+            goss_file: node.test_data[:goss_file],
+            puppet_manifest: node.test_data[:puppet_manifest],
+            provision_dir_source: @backend.provision_directory,
+            provision_dir_dest: @backend.destination_provision_directory,
+            provision_commands: @backend.provision_commands,
+          })
+        end
+        node_data.to_json
+      rescue StandardError => e
+        logger.error('Terraform') { 'Error creating node data' }
+        raise e
+      end
+
+      def formatted_vars
+        @provision_data[:nodes].first.platform_data.merge({
+          puppet_module_package: @provision_data[:module_package_path],
+          node_data: provision_node_data,
+        })
+      rescue StandardError => e
+        logger.error('Terraform') { 'Error creating formatted vars' }
+        raise e
+      end
+    end
+  end
+end

data/lib/cem_acpt/provision.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'logging'
+require_relative 'provision/terraform'
+
+module CemAcpt
+  module Provision
+    include CemAcpt::Logging
+
+    def self.new_provisioner(config, provision_data)
+      case config.get('provisioner')
+      when 'terraform'
+        logger.debug('Provision') { 'Using Terraform provisioner' }
+        CemAcpt::Provision::Terraform.new(config, provision_data)
+      else
+        raise ArgumentError, "Unknown provisioner #{config.get('provisioner')}"
+      end
+    end
+  end
+end

data/lib/cem_acpt/puppet_helpers.rb

@@ -28,7 +28,6 @@ module CemAcpt
 
         # Validates module metadata by raising exception if invalid
         _metadata = builder.metadata
-        logger.debug("Metadata for module #{builder.release_name} is valid")
 
         # Builds the module package
         logger.info("Building module package for #{builder.release_name}")

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