cem_acpt 0.8.8 → 0.9.1

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      # Formats the results of a Bolt::SummaryResults object
+      class BoltSummaryResultsFormatter < Base
+        def initialize(config, instance_names_ips, subject: nil)
+          super(subject)
+          @config = config
+          @instance_names_ips = instance_names_ips
+        end
+
+        def summary(response = nil)
+          super(response)
+          [
+            "SUMMARY: #{test_name(log_subject)}:",
+            normalize_whitespace(log_subject.summary),
+          ].join(' ')
+        end
+
+        def results(response = nil)
+          super(response)
+          log_subject.each_with_object([]) do |res, ary|
+            res.results.each do |r|
+              header = [
+                "#{success_str(r.success?).capitalize}: #{r.name}",
+                "action: #{r.action}",
+                "target: #{name_from_ip(r.target)}",
+                "object: #{r.object}",
+                "status: #{r.status}",
+              ]
+              parts = [
+                header.join(', '),
+                "validation results:\n#{JSON.pretty_generate(r.failed_validation_results)}",
+              ]
+              if CemAcpt::Logging.verbose?
+                parts << "command result:\n#{JSON.pretty_generate(r.command_result.to_h)}"
+              end
+              parts << r.error if r.error?
+              if r.respond_to?(:details) && !r.details&.empty?
+                parts << "details:\n#{JSON.pretty_generate(r.details)}\n"
+              end
+              ary << parts.join("\n")
+            end
+          end
+        end
+
+        def host_name(response = nil)
+          super(response)
+          log_subject.items.map { |i| name_from_ip(i.target) }.compact.uniq.join(', ')
+        end
+
+        def test_name(response = nil)
+          super(response)
+          'Bolt tests'
+        end
+      end
+    end
+  end
+end

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

@@ -1,53 +1,40 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 module CemAcpt
   module TestRunner
     module LogFormatter
       # Formats the results of a Goss action
-      class GossActionResponse
-        INDENT = '  '
-
-        def initialize(config, instance_names_ips)
+      class GossActionResponse < Base
+        def initialize(config, instance_names_ips, subject: nil)
+          super(subject)
           @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)
+        def summary(response = nil)
+          super(response)
+          new_summary_message(log_subject)
         end
 
-        def results(response)
-          new_results_message(response.results)
+        def results(response = nil)
+          super(response)
+          new_results_message(log_subject.results)
         end
 
-        def host_name(response)
-          name_from_ip(response.host)
+        def host_name(response = nil)
+          super(response)
+          name_from_ip(log_subject.host)
         end
 
-        def test_name(response)
-          test_from_ip(response.host)
+        def test_name(response = nil)
+          super(response)
+          test_from_ip(log_subject.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

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      class GossErrorFormatter < Base
+        def summary(subject = nil)
+          super(subject)
+          "Error: #{log_subject.summary}"
+        end
+
+        def results(response = nil)
+          super(response)
+          [log_subject.summary, log_subject.results.join("\n")]
+        end
+
+        def host_name(response = nil)
+          super(response)
+          "Error: #{log_subject.error.class.name}"
+        end
+
+        def test_name(response = nil)
+          super(response)
+          "Error: #{log_subject.error.class.name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      class StandardErrorFormatter < Base
+        def summary(subject = nil)
+          super(subject)
+          "Error: #{log_subject.detailed_message}"
+        end
+
+        def results(response = nil)
+          super(response)
+          [
+            "Error: #{log_subject.class.name}",
+            log_subject.detailed_message,
+            log_subject.backtrace.join("\n"),
+          ]
+        end
+
+        def host_name(response = nil)
+          super(response)
+          "Error: #{log_subject.class.name}"
+        end
+
+        def test_name(response = nil)
+          super(response)
+          "Error: #{log_subject.class.name}"
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/test_runner/log_formatter.rb

@@ -1,17 +1,29 @@
 # frozen_string_literal: true
 
+require_relative 'log_formatter/bolt_summary_results_formatter'
+require_relative 'log_formatter/bolt_output_formatter'
 require_relative 'log_formatter/goss_action_response'
-require_relative 'log_formatter/error_formatter'
+require_relative 'log_formatter/goss_error_formatter'
+require_relative 'log_formatter/standard_error_formatter'
 
 module CemAcpt
   module TestRunner
     # Holds classes for formatting test runner results
     module LogFormatter
-      def self.new_formatter(result, *args, **kwargs)
-        if result.error?
-          ErrorFormatter.new
+      def self.new_formatter(result, *args, **_kwargs)
+        case result
+        when CemAcpt::Goss::Api::ActionResponse
+          if result.error?
+            GossErrorFormatter.new(result)
+          else
+            GossActionResponse.new(*args, subject: result)
+          end
+        when CemAcpt::Bolt::SummaryResults
+          BoltSummaryResultsFormatter.new(*args, subject: result)
+        when StandardError
+          StandardErrorFormatter.new(result)
         else
-          GossActionResponse.new(*args)
+          raise ArgumentError, "result must be a CemAcpt::Goss::Api::ActionResponse, CemAcpt::Bolt::SummaryResults, or StandardError, got #{result.class}"
         end
       end
     end

data/lib/cem_acpt/test_runner/test_results.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative 'log_formatter'
+
+module CemAcpt
+  module TestRunner
+    # Namespace for all test result classes and methods
+    module TestResults
+      def self.new(config = nil, instance_names_ips = nil)
+        Results.new(config, instance_names_ips)
+      end
+
+      # Class that manages test results
+      class Results
+        attr_accessor :config, :instance_names_ips
+
+        def initialize(config = nil, instance_names_ips = nil)
+          @results_queue = Queue.new
+          @config = config
+          @instance_names_ips = instance_names_ips
+        end
+
+        def combine(other)
+          new_res_queue_data = (to_a + other.to_a).compact.uniq
+          @results_queue = Queue.new(new_res_queue_data)
+
+          self
+        end
+
+        def <<(result)
+          case result
+          when CemAcpt::Goss::Api::ActionResponse, CemAcpt::Bolt::SummaryResults
+            @results_queue << TestActionResult.new(result, new_formatter(result))
+          when StandardError
+            @results_queue << TestErrorActionResult.new(result, new_formatter(result))
+          else
+            raise ArgumentError, "result must be a CemAcpt::Goss::Api::ActionResponse, CemAcpt::Bolt::SummaryResults, or StandardError, got #{result.class}"
+          end
+        end
+
+        def to_a
+          results = []
+          @results_queue.close unless @results_queue.closed?
+          while (r = @results_queue.pop)
+            results << r
+          end
+          @results_queue = Queue.new(results)
+          results
+        end
+
+        def method_missing(method_name, *args, **kwargs, &block)
+          @results_queue.send(method_name, *args, **kwargs, &block)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @results_queue.respond_to?(method_name, include_private) || super
+        end
+
+        private
+
+        def new_formatter(result)
+          CemAcpt::TestRunner::LogFormatter.new_formatter(result, @config, @instance_names_ips)
+        end
+      end
+
+      # Wrapper class for the result of an action. Provides a common interface for
+      # getting reportable data from the result.
+      class TestActionResult
+        attr_reader :result, :log_formatter
+
+        def initialize(result, log_formatter = nil)
+          @result = result
+          @log_formatter = log_formatter
+        end
+
+        def error?
+          (@result.respond_to?(:error?) && @result.error?) || false
+        end
+
+        def method_missing(method_name, *args, **kwargs, &block)
+          if @result.respond_to?(method_name)
+            @result.send(method_name, *args, **kwargs, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @result.respond_to?(method_name, include_private) || super
+        end
+      end
+
+      # Wrapper class for an error raised during an action.
+      class TestErrorActionResult
+        attr_reader :error, :log_formatter
+
+        def initialize(error, log_formatter = nil)
+          @error = error
+          @log_formatter = log_formatter
+        end
+        alias result error
+
+        def error?
+          true
+        end
+
+        def success?
+          false
+        end
+
+        def to_s
+          "#<#{@error.class.name}:0x#{@error.object_id.to_s(16)}>"
+        end
+
+        def inspect
+          to_s
+        end
+
+        def to_h
+          {
+            class: @error.class.name,
+            message: @error.message,
+            backtrace: @error.backtrace,
+          }
+        end
+
+        def status
+          1
+        end
+        alias http_status status
+
+        def results
+          [summary, "Class: #{@error.class.name}", @error.backtrace.join("\n")]
+        end
+
+        def results?
+          true
+        end
+
+        def summary
+          @error.message
+        end
+
+        def summary?
+          true
+        end
+      end
+    end
+  end
+end