cem_acpt 0.8.8 → 0.9.1

data/lib/cem_acpt/bolt/tasks.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'cmd'
+require_relative 'errors'
+require_relative '../core_ext'
+require_relative '../logging'
+require_relative '../utils/shell'
+
+module CemAcpt
+  module Bolt
+    using CemAcpt::CoreExt::ExtendedArray
+
+    # Provides a wrapper for Bolt tasks that holds data and provides methods for interacting with them
+    # This should probably be genericized as ObjectWrapper to account for Bolt plans, as well
+    class TaskWrapper
+      include CemAcpt::Logging
+      attr_reader :full_name, :name, :description, :module_name, :last_cmd_executed
+
+      def initialize(config, task_array, project: nil, inventory: nil)
+        @config = config
+        @full_name = task_array[0]
+        @description = task_array[1]
+        @module_name = @full_name.split('::').first
+        @name = @full_name.split('::').last
+        @show_cmd = CemAcpt::Bolt::Cmd::TaskShow.new(@config, full_name, project: project)
+        @run_cmd = CemAcpt::Bolt::Cmd::TaskRun.new(@config, full_name, project: project, inventory: inventory)
+        @last_cmd_executed = nil
+      end
+
+      def inspect
+        "#<#{self.class}:\"#{full_name}\">"
+      end
+
+      def show(**params)
+        logger.verbose('CemAcpt::Bolt::TaskWrapper') { "Executing task show with params: #{params}" }
+        @last_cmd_executed = @show_cmd
+        show_cmd.run(**params)
+      end
+
+      def run(**params)
+        logger.verbose('CemAcpt::Bolt::TaskWrapper') { "Executing task run with params: #{params}" }
+        @last_cmd_executed = @run_cmd
+        run_cmd.run(**params)
+      end
+
+      private
+
+      attr_reader :show_cmd, :run_cmd
+    end
+
+    # Holds and manages the list of tasks in the current bolt project
+    class TaskList
+      include CemAcpt::Logging
+      include CemAcpt::Bolt::Helpers
+
+      attr_reader :metadata
+
+      def initialize(config, inventory = nil, project = nil)
+        @config = config
+        @inventory = inventory
+        @project = project
+        @tasks = []
+        @metadata = {}
+      end
+
+      def unfiltered
+        find_all_tasks
+      end
+
+      def tasks
+        return @tasks unless @tasks.nil? || @tasks.empty?
+
+        @tasks = filter_tasks(unfiltered)
+        @tasks
+      end
+
+      def module_pattern
+        @module_pattern ||= get_pattern('bolt.tasks.module_pattern')
+      end
+
+      def name_filter
+        @name_pattern ||= get_pattern('bolt.tasks.name_filter', default: %r{^$})
+      end
+
+      def ignore
+        @ignore ||= @config.get('bolt.tasks.ignore') || []
+      end
+
+      def only
+        @only ||= @config.get('bolt.tasks.only') || []
+      end
+
+      def method_missing(method, *args, **kwargs, &block)
+        if tasks.respond_to?(method)
+          tasks.send(method, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        tasks.respond_to?(method, include_private) || super
+      end
+
+      def inspect
+        tasks.inspect
+      end
+
+      private
+
+      def get_pattern(config_key, default: %r{.*})
+        pat = @config.get(config_key)
+        return default unless pat
+
+        Regexp.new(pat)
+      end
+
+      def find_all_tasks
+        logger.debug('CemAcpt::Bolt::TaskList') { 'Finding all Bolt tasks...' }
+        out = CemAcpt::Bolt::Cmd::TaskShow.new(@config, project: @project).run(strict: false)
+        if out.error?
+          logger.error('CemAcpt::Bolt::TaskList') { "Error finding Bolt tasks:\n#{out}" }
+          logger.debug('CemAcpt::Bolt::TaskList') { "Backtrace:\n#{out.error.backtrace.join("\n")}" } if out.error.respond_to?(:backtrace)
+          raise out.error if out.error.is_a?(StandardError)
+          raise CemAcpt::Bolt::BoltActionError.new("Error finding Bolt tasks: #{out.error.msg}",
+                                                   out.error,
+                                                   out.error.kind,
+                                                   out.error.details)
+
+        end
+        out.to_h['tasks'].map { |task_array| TaskWrapper.new(@config, task_array) }
+      end
+
+      def filter_tasks(td_array)
+        @metadata[:filter] = {}
+        td_array.select do |t|
+          @metadata[:filter][t.full_name] = []
+          unless module_pattern.match?(t.module_name)
+            @metadata[:filter][t.full_name] << {
+              rule: 'module_pattern',
+              value: t.module_name,
+              pattern: module_pattern,
+            }
+            next
+          end
+          if name_filter.match?(t.name)
+            @metadata[:filter][t.full_name] << {
+              rule: 'name_filter',
+              value: t.name,
+              pattern: name_filter,
+            }
+            next
+          end
+
+          only_check = only.empty? || only.any? { |o| t.full_name.match?(o) }
+          ignore_check = ignore.empty? || ignore.none? { |i| t.full_name.match?(i) }
+          if only_check && ignore_check
+            true
+          else
+            unless only_check
+              @metadata[:filter][t.full_name] << {
+                rule: 'only',
+                value: t.name,
+                pattern: only,
+              }
+            end
+            unless ignore_check
+              @metadata[:filter][t.full_name] << {
+                rule: 'ignore',
+                value: t.name,
+                pattern: ignore,
+              }
+            end
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/tests.rb

@@ -0,0 +1,415 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'errors'
+require_relative 'tasks'
+require_relative '../core_ext'
+require_relative '../logging'
+
+module CemAcpt
+  module Bolt
+    module Tests
+      using CemAcpt::CoreExt::ExtendedArray
+
+      # Provides an abstraction for the specific Bolt test data
+      class TestData
+        attr_reader :prop_validators, :params, :status
+
+        def initialize(**prop_validators)
+          @prop_validators = { params: {}, status: 'success' }.merge(prop_validators.transform_keys(&:to_sym))
+          @params = @prop_validators[:params]
+          @status = @prop_validators[:status]
+        end
+
+        def to_h
+          prop_validators
+        end
+
+        def validation_properties
+          @validation_properties ||= prop_validators.keys
+        end
+
+        # Compares prop_validators with another object that implements any of the properties as methods.
+        # @param other [Object] the object to compare against
+        # @return [Array<Hash>] an array of the hashes representing the results of the validation
+        # @raise [ArgumentError] if other does not implement any of the properties
+        def validate_props(other)
+          if (other.methods & validation_properties).empty?
+            raise ArgumentError, "Object does not implement any of the properties: #{validation_properties}"
+          end
+
+          prop_validators.each_with_object([]) do |(k, v), ary|
+            unless other.respond_to?(k)
+              ary << validation_hash(k, 'skipped', 'property_not_implemented', v, nil)
+              next
+            end
+
+            other_val = other.send(k)
+            begin
+              case v
+              when String
+                ary << validation_hash(k, result_from_bool(other_val == v), 'string_eq', v, other_val)
+              when Hash
+                v.transform_keys!(&:to_sym)
+                unknown_validators_val = validate_validators(v, :match, :not_match)
+                match_val = validate_match(k, v[:match], other_val)
+                not_match_val = validate_match(k, v[:not_match], other_val, negate: true)
+                [match_val, not_match_val, unknown_validators_val].compact.each { |h| ary << h }
+              else
+                ary << validation_hash(k, result_from_bool(other_val == v), 'simple_eq', v, other_val)
+              end
+            rescue StandardError => e
+              ary << validation_hash(k, 'failure', 'ruby_error', e, nil)
+            end
+          end
+        end
+
+        private
+
+        def validate_match(prop, this_v, other_v, negate: false)
+          return if this_v.nil?
+
+          res = if other_v.is_a?(Hash)
+                  JSON.generate(other_v).match?(this_v)
+                else
+                  other_v.match?(this_v)
+                end
+          res = !res if negate
+          validation_hash(prop, result_from_bool(res), 'match', other_v, this_v)
+        end
+
+        def validate_validators(this_v, *keys)
+          return if this_v.nil?
+
+          unknown_keys = this_v.keys - keys.flatten.map(&:to_sym)
+          return if unknown_keys.empty?
+
+          validation_hash(:validators, 'failure', 'unknown_validators', this_v, unknown_keys)
+        end
+
+        def result_from_bool(bool)
+          bool ? 'success' : 'failure'
+        end
+
+        def validation_hash(prop, result, validator, validation_v, other_v)
+          { prop: prop, result: result, validator: validator, validation_value: validation_v, other_value: other_v }
+        end
+      end
+
+      # Contains the results of a single Bolt task test
+      class TestResult
+        attr_reader :name, :command_result, :validation_results, :details
+
+        def initialize(name, command_result, validation_results, **details)
+          @name = name
+          @command_result = command_result
+          @validation_results = validation_results
+          @details = details
+        end
+
+        def failed_validation_results
+          @failed_validation_results ||= validation_results.select { |vr| vr[:result] == 'failure' }
+        end
+
+        def skipped_validation_results
+          @skipped_validation_results ||= validation_results.select { |vr| vr[:result] == 'skipped' }
+        end
+
+        def success_validation_results
+          @success_validation_results ||= validation_results.select { |vr| vr[:result] == 'success' }
+        end
+
+        def action
+          @action ||= if @command_result.is_a?(CemAcpt::Bolt::BoltActionError)
+                        @command_result.bolt_action
+                      elsif @command_result.respond_to?(:action)
+                        @command_result.action
+                      else
+                        'unknown'
+                      end
+        end
+
+        def target
+          @target ||= if @command_result.is_a?(CemAcpt::Bolt::BoltActionError)
+                        @command_result.bolt_target
+                      elsif @command_result.respond_to?(:target)
+                        @command_result.target
+                      else
+                        'unknown'
+                      end
+        end
+
+        def object
+          @object ||= if @command_result.is_a?(CemAcpt::Bolt::BoltActionError)
+                        @command_result.bolt_object
+                      elsif @command_result.respond_to?(:object)
+                        @command_result.object
+                      else
+                        'unknown'
+                      end
+        end
+
+        def success?
+          @validation_results.none? { |vr| vr[:result] == 'failure' }
+        end
+
+        def status
+          @status ||= success? ? 'success' : 'failure'
+        end
+
+        def error?
+          @command_result.is_a?(CemAcpt::Bolt::BoltActionError)
+        end
+
+        def error
+          @command_result if error?
+        end
+
+        def to_h
+          {
+            name: name,
+            success: success?,
+            command_result: command_result.to_h,
+            validation_results: validation_results,
+            details: details,
+          }
+        end
+      end
+
+      # Contains the results of running a Bolt task test
+      class TestResults
+        attr_reader :test_name, :results
+
+        def initialize(test_name, results = [])
+          @test_name = test_name
+          @results = results
+        end
+
+        def success?
+          @results.all? { |r| r.success? }
+        end
+
+        def status
+          @status ||= success? ? 'success' : 'failure'
+        end
+
+        def action
+          @action ||= @results.empty? ? 'unknown' : @results.first.action
+        end
+
+        def target
+          @target ||= @results.empty? ? 'unknown' : @results.first.target
+        end
+
+        def object
+          @object ||= @results.empty? ? 'unknown' : @results.first.object
+        end
+
+        def to_h
+          {
+            test_name: test_name,
+            success: success?,
+            results: @results.map(&:to_h),
+          }
+        end
+
+        def method_missing(method_name, *args, **kwargs, &block)
+          if @results.respond_to?(method_name)
+            @results.send(method_name, *args, **kwargs, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @results.respond_to?(method_name, include_private) || super
+        end
+
+        def inspect
+          "#<#{self.class}:#{object_id.to_s(16)} with #{results.count} result(s)>"
+        end
+      end
+
+      # Provides an interface for running tests against Bolt tasks
+      class Test
+        include CemAcpt::Logging
+
+        attr_reader :name, :data, :object, :groups, :command_result, :result
+
+        def initialize(name, data, object, *groups)
+          @name = name
+          @data = data.is_a?(Hash) ? TestData.new(**data) : TestData.new
+          @object = object
+          @groups = groups
+          @command_result = nil
+          @result = TestResults.new(name)
+          @validation_results = {}
+        end
+
+        # Groups in this context refers to the acceptance test names. Because the acceptance tests act like logical
+        # groups, we refer to them as groups here to avoid confusion with the Bolt tests.
+        def add_group(group)
+          @groups << group unless @groups.include?(group)
+        end
+
+        def run
+          logger.debug('CemAcpt::Bolt::Tests::Test') { "Running test #{name}" }
+          @command_result = @object.run(**@data.params)
+          validate!
+        rescue StandardError => e
+          new_wrapped_error("Error running test #{name}", e)
+        end
+
+        def to_s
+          "#<#{self.class}:#{object_id.to_s(16)} #{name},#{object},#{groups.join(',')}>"
+        end
+
+        def inspect
+          to_s
+        end
+
+        private
+
+        # Loops through the results of the Bolt task and validates the properties of each result.
+        # @return [TaskResults] the results of the validation
+        def validate!
+          logger.debug('CemAcpt::Bolt::Tests::Test') { "Validating test #{name}" }
+          begin
+            @command_result.results.each do |r|
+              prop_vals = @data.validate_props(r)
+              @validation_results[r] = prop_vals
+              @result << TestResult.new(name, r, prop_vals, test_groups: groups)
+            end
+          rescue StandardError => e
+            logger.debug('CemAcpt::Bolt::Tests::Test') { "Error validating command result for test #{name}:\n#{e}" }
+            wrapped_error = new_wrapped_error("Error validating test #{name}", e)
+            @result << TestResult.new(
+              name,
+              wrapped_error,
+              [],
+              test_groups: groups,
+              backtrace: e.backtrace,
+            )
+          end
+        rescue StandardError => e
+          logger.debug('CemAcpt::Bolt::Tests::Test') { "Error validating test #{name}:\n#{e}" }
+          wrapped_error = new_wrapped_error("Error validating test #{name}", e)
+          @result << TestResult.new(name, wrapped_error, [], test_groups: groups)
+        end
+
+        def new_wrapped_error(errmsg, original_err = nil)
+          last_cmd = @object.last_cmd_executed
+          cmd_family = last_cmd.nil? ? 'unknown' : last_cmd.command_family
+          CemAcpt::Bolt::BoltActionError.new(errmsg, original_err, cmd_family, last_cmd)
+        end
+      end
+
+      # Loads test data and provides an interface for running tests against Bolt tasks
+      class TestList
+        include CemAcpt::Logging
+        attr_accessor :config, :run_data, :inventory, :project
+        attr_reader :test_data, :tasks, :tests
+
+        def initialize(config = nil, run_data = nil, inventory = nil, project = nil)
+          @config = config
+          @run_data = run_data
+          @inventory = inventory
+          @project = project
+          @test_data = nil
+          @tasks = []
+          @tests = []
+          @loaded = false
+          @setup = false
+        end
+
+        # Loads the test data from the Bolt test files specified in the run data
+        def load!
+          return if loaded?
+          raise 'Run data has not been set, assign it to the #run_data attribute first' unless @run_data
+
+          @test_data = load_test_data(@run_data)
+          @loaded = true
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        # Sets up the tests by loading the Bolt tasks and creating a TestWrapper for each test
+        def setup!
+          load! unless loaded?
+          @tasks = CemAcpt::Bolt::TaskList.new(@config)
+          @tasks.tasks # Ensure tasks are loaded
+          logger.verbose('CemAcpt::Bolt::Tests') { "TaskList metadata:\n#{@tasks.metadata.to_yaml}" }
+          @tests = new_test_array(@tasks, @test_data)
+          @setup = true
+        end
+
+        def setup?
+          @setup
+        end
+
+        def to_a
+          @tests
+        end
+
+        def split_into_groups(num_groups)
+          raise 'Tests have not been setup, call the #setup! method first' unless setup?
+
+          @tests.split_into_groups(num_groups)
+        end
+
+        def length
+          @tests.length
+        end
+        alias count length
+        alias size length
+
+        def to_s
+          "#<#{self.class}:#{object_id.to_s(16)} #{tests.join(',')}>"
+        end
+
+        def inspect
+          to_s
+        end
+
+        private
+
+        def load_test_data(run_data)
+          run_data[:test_data].each_with_object({}) do |tdata, h|
+            test_name = tdata[:test_name]
+            next if h.key?(test_name) || tdata[:bolt_test].nil?
+
+            logger.debug('CemAcpt::Bolt::Tests') { "Loading test data for test #{test_name}" }
+            begin
+              h[test_name] = YAML.safe_load_file(tdata[:bolt_test])
+            rescue Psych::SyntaxError, NoMethodError
+              h[test_name] = YAML.safe_load(File.read(tdata[:bolt_test]))
+            end
+            logger.debug('CemAcpt::Bolt::Tests') { "Loaded test data for test #{test_name}" }
+            logger.verbose('CemAcpt::Bolt::Tests') { "Test data for test #{test_name}:\n#{h[test_name].to_yaml}" }
+          end
+        end
+
+        def new_test_array(tasks, test_data)
+          tw_created = {}
+          logger.debug('CemAcpt::Bolt::Tests') { 'Creating tests for Bolt tasks' }
+          tasks.each do |task|
+            test_data.each do |group, tdata|
+              next unless @config.get('tests').include?(group)
+
+              if tw_created.key?(task.full_name)
+                tw_created[task.full_name].add_group(group)
+                logger.debug('CemAcpt::Bolt::Tests') { "Added group #{group} to test for task #{task.full_name}" }
+              else
+                tw_created[task.full_name] = Test.new(task.full_name, tdata[task.full_name], task, group)
+                logger.debug('CemAcpt::Bolt::Tests') { "Created test for task #{task.full_name}" }
+              end
+            end
+          end
+          tw_created.values
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/yaml_file.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../logging'
+require_relative '../utils/files'
+
+module CemAcpt
+  module Bolt
+    # Provides an abstraction for a YAML file
+    # Used as a base class for other YAML file abstractions
+    class YamlFile
+      include CemAcpt::Logging
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+        @hash = {}
+        @saved_hash = nil
+      end
+
+      def to_h
+        @hash
+      end
+
+      def load!
+        logger.debug(self.class.to_s) { "Loading #{path}..." }
+        @saved_hash = CemAcpt::Utils::Files.read(path, log_prefix: self.class.to_s)
+        logger.verbose(self.class.to_s) { "Loaded #{path} contents: #{@saved_hash}" }
+        @hash = @saved_hash.dup
+      end
+
+      def save!
+        return if latest_saved?
+
+        logger.debug(self.class.to_s) { 'Saving file...' }
+        CemAcpt::Utils::Files.delete(path, log_prefix: self.class.to_s) if File.exist?(path)
+        logger.debug(self.class.to_s) { "Creating #{path}..." }
+        logger.verbose(self.class.to_s) { "New #{path} contents: #{@hash}" }
+        CemAcpt::Utils::Files.write(path, @hash, log_prefix: self.class.to_s)
+        @saved_hash = @hash
+      end
+
+      def delete!
+        CemAcpt::Utils::Files.delete(path, log_prefix: self.class.to_s)
+        @saved_hash = nil
+      end
+
+      def latest_saved?
+        (@hash == @saved_hash) || eq_to_disk?
+      end
+
+      def eq_to_disk?
+        return false unless File.exist?(path)
+
+        disk_contents = CemAcpt::Utils::Files.read(path, log_prefix: self.class.to_s)
+        @hash.sort.to_h == disk_contents.sort.to_h
+      end
+
+      def gte_to_disk?
+        return false unless File.exist?(path)
+
+        disk_contents = CemAcpt::Utils::Files.read(path, log_prefix: self.class.to_s)
+        @hash.sort.to_h >= disk_contents.sort.to_h
+      end
+
+      def lte_to_disk?
+        return false unless File.exist?(path)
+
+        disk_contents = CemAcpt::Utils::Files.read(path, log_prefix: self.class.to_s)
+        @hash.sort.to_h <= disk_contents.sort.to_h
+      end
+    end
+  end
+end