RubyGems - puppet_litmus - Versions diffs - 0.16.0 → 0.17.0 - Mend

puppet_litmus 0.16.0 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

checksums.yaml +4 -4
data/lib/puppet_litmus.rb +0 -30
data/lib/puppet_litmus/inventory_manipulation.rb +1 -0
data/lib/puppet_litmus/puppet_helpers.rb +196 -137
data/lib/puppet_litmus/rake_helper.rb +142 -51
data/lib/puppet_litmus/rake_tasks.rb +3 -1
data/lib/puppet_litmus/version.rb +1 -1
data/spec/lib/puppet_litmus/puppet_helpers_spec.rb +6 -11
data/spec/lib/puppet_litmus/rake_helper_spec.rb +58 -11
metadata +25 -10

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e545da74266b708eae5c7cb6bab56480b78724ff51a9b8591943cfa98db3d7d
-  data.tar.gz: fd3e61dbc511549ac3ab1c43d834b9fa8e729d5af4bb48a6b4fab50041539428
+  metadata.gz: c81ccd0186b54db2eb71534a0cc10e5191e1b6103201e8ef44231cc017cf5faa
+  data.tar.gz: dd027dff77884a4b09b66447c966c3636a2cf237e21c1b4f0ec1d28182188937
 SHA512:
-  metadata.gz: 43adad4003cec09ff51204502f1f8f223c379ddd0c5ab93f38cb1285f0868ed965bbbc0117db72f022bc346f12315d9b9bfbb1deeed41c15467c17d2a86ebc43
-  data.tar.gz: c8d670ec75ee889f29a02071be10574027a742575034f3666a348f2bbcb6dca85f5d748fe236a357ffff571eb4d3556d0c32140652d308fc765936b21c1cb8b7
+  metadata.gz: 38db1fa85c7ca655540aad80563bd095c8de46b492e618541a9dbd42b4a9305447ce2538c4ed30882f87582f4a21ebac7d0a1352288f3920d33b42af4d53fa4d
+  data.tar.gz: 849c989f388d9b1b4dde8a44a2788657c015c50bbfb8ff399255d64c3390557bca7e319939134a2bb2918f3ffc48b0c59a27c29ab7d0779d480c07f9a392a3dc

data/lib/puppet_litmus.rb CHANGED Viewed

@@ -8,7 +8,6 @@ require 'puppet_litmus/inventory_manipulation'
 require 'puppet_litmus/puppet_helpers'
 require 'puppet_litmus/rake_helper'
 require 'puppet_litmus/spec_helper_acceptance'
-require 'honeycomb-beeline'
 # Helper methods for testing puppet content
 module PuppetLitmus
@@ -16,33 +15,4 @@ module PuppetLitmus
   include PuppetLitmus::InventoryManipulation
   include PuppetLitmus::PuppetHelpers
   include PuppetLitmus::RakeHelper
-  Honeycomb.configure do |config|
-  end
-  process_span = Honeycomb.start_span(name: 'Litmus Testing')
-  if ENV['CI'] == 'true' && ENV['TRAVIS'] == 'true'
-    process_span.add_field('module_name', ENV['TRAVIS_REPO_SLUG'])
-    process_span.add_field('ci.provider', 'travis')
-    process_span.add_field('ci.build_id', ENV['TRAVIS_BUILD_ID'])
-    process_span.add_field('ci.build_url', ENV['TRAVIS_BUILD_WEB_URL'])
-    process_span.add_field('ci.job_url', ENV['TRAVIS_JOB_WEB_URL'])
-    process_span.add_field('ci.commit_message', ENV['TRAVIS_COMMIT_MESSAGE'])
-    process_span.add_field('ci.sha', ENV['TRAVIS_PULL_REQUEST_SHA'] || ENV['TRAVIS_COMMIT'])
-  elsif ENV['CI'] == 'True' && ENV['APPVEYOR'] == 'True'
-    process_span.add_field('module_name', ENV['APPVEYOR_PROJECT_SLUG'])
-    process_span.add_field('ci.provider', 'appveyor')
-    process_span.add_field('ci.build_id', ENV['APPVEYOR_BUILD_ID'])
-    process_span.add_field('ci.build_url', "https://ci.appveyor.com/project/#{ENV['APPVEYOR_REPO_NAME']}/builds/#{ENV['APPVEYOR_BUILD_ID']}")
-    process_span.add_field('ci.job_url', "https://ci.appveyor.com/project/#{ENV['APPVEYOR_REPO_NAME']}/build/job/#{ENV['APPVEYOR_JOB_ID']}")
-    process_span.add_field('ci.commit_message', ENV['APPVEYOR_REPO_COMMIT_MESSAGE'])
-    process_span.add_field('ci.sha', ENV['APPVEYOR_PULL_REQUEST_HEAD_COMMIT'] || ENV['APPVEYOR_REPO_COMMIT'])
-  elsif ENV['GITHUB_ACTIONS'] == 'true'
-    process_span.add_field('module_name', ENV['GITHUB_REPOSITORY'])
-    process_span.add_field('ci.provider', 'github')
-    process_span.add_field('ci.build_id', ENV['GITHUB_RUN_ID'])
-    process_span.add_field('ci.build_url', "https://github.com/#{ENV['GITHUB_REPOSITORY']}/actions/runs/#{ENV['GITHUB_RUN_ID']}")
-    process_span.add_field('ci.sha', ENV['GITHUB_SHA'])
-  end
-  at_exit do
-    process_span.send
-  end
 end

data/lib/puppet_litmus/inventory_manipulation.rb CHANGED Viewed

@@ -37,6 +37,7 @@ module PuppetLitmus::InventoryManipulation
               'uri' => 'litmus_localhost',
               'config' => { 'transport' => 'local' },
               'feature' => 'puppet-agent',
+              'facts' => { 'platform' => 'localhost' },
             },
           ],
         },

data/lib/puppet_litmus/puppet_helpers.rb CHANGED Viewed

@@ -8,87 +8,103 @@ module PuppetLitmus::PuppetHelpers
   # @param manifest [String] puppet manifest code to be applied.
   # @return [Boolean] The result of the 2 apply manifests.
   def idempotent_apply(manifest)
-    manifest_file_location = create_manifest_file(manifest)
-    apply_manifest(nil, expect_failures: false, manifest_file_location: manifest_file_location)
-    apply_manifest(nil, catch_changes: true, manifest_file_location: manifest_file_location)
+    Honeycomb.start_span(name: 'litmus.idempotent_apply') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      manifest_file_location = create_manifest_file(manifest)
+      apply_manifest(nil, expect_failures: false, manifest_file_location: manifest_file_location)
+      apply_manifest(nil, catch_changes: true, manifest_file_location: manifest_file_location)
+    end
   end
-  # rubocop:disable Layout/TrailingWhitespace
   # Applies a manifest. returning the result of that apply. Mimics the apply_manifest from beaker
-  #
+  #
   # When you set the environment variable RSPEC_DEBUG, the output of your
   # puppet run will be displayed. If you have set the :debug flag, you will see the
   # full debug log. If you have **not** set the :debug flag, it will display the regular
   # output.
   #
   # @param manifest [String] puppet manifest code to be applied.
-  # @param opts [Hash] Alters the behaviour of the command. Valid options are:
-  #  :catch_changes [Boolean] (false) We're after idempotency so allow exit code 0 only.
-  #  :expect_changes [Boolean] (false) We're after changes specifically so allow exit code 2 only.
-  #  :catch_failures [Boolean] (false) We're after only complete success so allow exit codes 0 and 2 only.
-  #  :expect_failures [Boolean] (false) We're after failures specifically so allow exit codes 1, 4, and 6 only.
-  #  :manifest_file_location [Path] The place on the target system.
+  # @param opts [Hash] Alters the behaviour of the command. Valid options are:
+  #  :catch_changes [Boolean] (false) We're after idempotency so allow exit code 0 only.
+  #  :expect_changes [Boolean] (false) We're after changes specifically so allow exit code 2 only.
+  #  :catch_failures [Boolean] (false) We're after only complete success so allow exit codes 0 and 2 only.
+  #  :expect_failures [Boolean] (false) We're after failures specifically so allow exit codes 1, 4, and 6 only.
+  #  :manifest_file_location [Path] The place on the target system.
   #  :hiera_config [Path] The path to the hiera.yaml configuration on the runner.
-  #  :prefix_command [String] prefixes the puppet apply command; eg "export LANGUAGE='ja'".
-  #  :debug [Boolean] run puppet apply with the debug flag.
-  #  :noop [Boolean] run puppet apply with the noop flag.
+  #  :prefix_command [String] prefixes the puppet apply command; eg "export LANGUAGE='ja'".
+  #  :debug [Boolean] run puppet apply with the debug flag.
+  #  :noop [Boolean] run puppet apply with the noop flag.
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the apply.
   def apply_manifest(manifest, opts = {})
-    # rubocop:enable Layout/TrailingWhitespace
-    target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
-    raise 'manifest and manifest_file_location in the opts hash are mutually exclusive arguments, pick one' if !manifest.nil? && !opts[:manifest_file_location].nil?
-    raise 'please pass a manifest or the manifest_file_location in the opts hash' if (manifest.nil? || manifest == '') && opts[:manifest_file_location].nil?
-    raise 'please specify only one of `catch_changes`, `expect_changes`, `catch_failures` or `expect_failures`' if
-      [opts[:catch_changes], opts[:expect_changes], opts[:catch_failures], opts[:expect_failures]].compact.length > 1
-    if opts[:catch_changes]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [0]
-    elsif opts[:catch_failures]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [0, 2]
-    elsif opts[:expect_failures]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [1, 4, 6]
-    elsif opts[:expect_changes]
-      use_detailed_exit_codes = true
-      acceptable_exit_codes = [2]
-    else
-      use_detailed_exit_codes = false
-      acceptable_exit_codes = [0]
-    end
+    Honeycomb.start_span(name: 'litmus.apply_manifest') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.manifest', manifest)
+      span.add_field('litmus.opts', opts)
-    manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
-    inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
-    raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-    command_to_run = "#{opts[:prefix_command]} puppet apply #{manifest_file_location}"
-    command_to_run += " --modulepath #{Dir.pwd}/spec/fixtures/modules" if target_node_name == 'litmus_localhost'
-    command_to_run += " --hiera_config='#{opts[:hiera_config]}'" unless opts[:hiera_config].nil?
-    command_to_run += ' --debug' if !opts[:debug].nil? && (opts[:debug] == true)
-    command_to_run += ' --noop' if !opts[:noop].nil? && (opts[:noop] == true)
-    command_to_run += ' --detailed-exitcodes' if use_detailed_exit_codes == true
-    result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
-    status = result.first['result']['exit_code']
-    if opts[:catch_changes] && !acceptable_exit_codes.include?(status)
-      report_puppet_apply_change(command_to_run, result)
-    elsif !acceptable_exit_codes.include?(status)
-      report_puppet_apply_error(command_to_run, result, acceptable_exit_codes)
-    end
+      target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
+      raise 'manifest and manifest_file_location in the opts hash are mutually exclusive arguments, pick one' if !manifest.nil? && !opts[:manifest_file_location].nil?
+      raise 'please pass a manifest or the manifest_file_location in the opts hash' if (manifest.nil? || manifest == '') && opts[:manifest_file_location].nil?
+      raise 'please specify only one of `catch_changes`, `expect_changes`, `catch_failures` or `expect_failures`' if
+        [opts[:catch_changes], opts[:expect_changes], opts[:catch_failures], opts[:expect_failures]].compact.length > 1
+      if opts[:catch_changes]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [0]
+      elsif opts[:catch_failures]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [0, 2]
+      elsif opts[:expect_failures]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [1, 4, 6]
+      elsif opts[:expect_changes]
+        use_detailed_exit_codes = true
+        acceptable_exit_codes = [2]
+      else
+        use_detailed_exit_codes = false
+        acceptable_exit_codes = [0]
+      end
-    result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
-                            stdout: result.first['result']['stdout'],
-                            stderr: result.first['result']['stderr'])
-    yield result if block_given?
-    if ENV['RSPEC_DEBUG']
-      puts "apply manifest succeded\n #{command_to_run}\n======\nwith status #{result.exit_code}"
-      puts result.stderr
-      puts result.stdout
+      manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
+      inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
+      raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
+      span.add_field('litmus.node_name', target_node_name)
+      span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+      command_to_run = "#{opts[:prefix_command]} puppet apply #{manifest_file_location}"
+      command_to_run += " --modulepath #{Dir.pwd}/spec/fixtures/modules" if target_node_name == 'litmus_localhost'
+      command_to_run += " --hiera_config='#{opts[:hiera_config]}'" unless opts[:hiera_config].nil?
+      command_to_run += ' --debug' if !opts[:debug].nil? && (opts[:debug] == true)
+      command_to_run += ' --noop' if !opts[:noop].nil? && (opts[:noop] == true)
+      command_to_run += ' --detailed-exitcodes' if use_detailed_exit_codes == true
+      span.add_field('litmus.command_to_run', command_to_run)
+      span.add_field('litmus.target_node_name', target_node_name)
+      bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', bolt_result)
+      result = OpenStruct.new(exit_code: bolt_result.first['result']['exit_code'],
+                              stdout: bolt_result.first['result']['stdout'],
+                              stderr: bolt_result.first['result']['stderr'])
+      span.add_field('litmus.result', result.to_h)
+      status = result.exit_code
+      if opts[:catch_changes] && !acceptable_exit_codes.include?(status)
+        report_puppet_apply_change(command_to_run, bolt_result)
+      elsif !acceptable_exit_codes.include?(status)
+        report_puppet_apply_error(command_to_run, bolt_result, acceptable_exit_codes)
+      end
+      yield result if block_given?
+      if ENV['RSPEC_DEBUG']
+        puts "apply manifest succeded\n #{command_to_run}\n======\nwith status #{result.exit_code}"
+        puts result.stderr
+        puts result.stdout
+      end
+      result
     end
-    result
   end
   # Creates a manifest file locally in a temp location, if its a remote target copy it to there.
@@ -96,23 +112,35 @@ module PuppetLitmus::PuppetHelpers
   # @param manifest [String] puppet manifest code.
   # @return [String] The path to the location of the manifest.
   def create_manifest_file(manifest)
-    require 'tmpdir'
-    target_node_name = ENV['TARGET_HOST']
-    tmp_filename = File.join(Dir.tmpdir, "manifest_#{Time.now.strftime('%Y%m%d')}_#{Process.pid}_#{rand(0x100000000).to_s(36)}.pp")
-    manifest_file = File.open(tmp_filename, 'w')
-    manifest_file.write(manifest)
-    manifest_file.close
-    if target_node_name.nil? || target_node_name == 'localhost'
-      # no need to transfer
-      manifest_file_location = manifest_file.path
-    else
-      # transfer to TARGET_HOST
-      inventory_hash = inventory_hash_from_inventory_file
-      manifest_file_location = "/tmp/#{File.basename(manifest_file)}"
-      result = upload_file(manifest_file.path, manifest_file_location, target_node_name, options: {}, config: nil, inventory: inventory_hash)
-      raise result.first['result'].to_s unless result.first['status'] == 'success'
+    Honeycomb.start_span(name: 'litmus.create_manifest_file') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.manifest', manifest)
+      require 'tmpdir'
+      target_node_name = ENV['TARGET_HOST']
+      tmp_filename = File.join(Dir.tmpdir, "manifest_#{Time.now.strftime('%Y%m%d')}_#{Process.pid}_#{rand(0x100000000).to_s(36)}.pp")
+      manifest_file = File.open(tmp_filename, 'w')
+      manifest_file.write(manifest)
+      manifest_file.close
+      if target_node_name.nil? || target_node_name == 'localhost'
+        # no need to transfer
+        manifest_file_location = manifest_file.path
+      else
+        # transfer to TARGET_HOST
+        inventory_hash = inventory_hash_from_inventory_file
+        span.add_field('litmus.node_name', target_node_name)
+        span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+        manifest_file_location = "/tmp/#{File.basename(manifest_file)}"
+        bolt_result = upload_file(manifest_file.path, manifest_file_location, target_node_name, options: {}, config: nil, inventory: inventory_hash)
+        span.add_field('litmus.bolt_result', bolt_result)
+        raise bolt_result.first['result'].to_s unless bolt_result.first['status'] == 'success'
+      end
+      span.add_field('litmus.manifest_file_location', manifest_file_location)
+      manifest_file_location
     end
-    manifest_file_location
   end
   # Runs a command against the target system
@@ -122,23 +150,31 @@ module PuppetLitmus::PuppetHelpers
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the command.
   def run_shell(command_to_run, opts = {})
-    Honeycomb.start_span(name: 'litmus_runshell') do |span|
+    Honeycomb.start_span(name: 'litmus.run_shell') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.command_to_run', command_to_run)
+      span.add_field('litmus.opts', opts)
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
-      if result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
-        span.add_field('litmus_runshellfailure', result)
-        raise "shell failed\n`#{command_to_run}`\n======\n#{result}"
+      span.add_field('litmus.node_name', target_node_name)
+      span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+      bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', bolt_result)
+      if bolt_result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
+        raise "shell failed\n`#{command_to_run}`\n======\n#{bolt_result}"
       end
-      result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
-                              exit_status: result.first['result']['exit_code'],
-                              stdout: result.first['result']['stdout'],
-                              stderr: result.first['result']['stderr'])
+      result = OpenStruct.new(exit_code: bolt_result.first['result']['exit_code'],
+                              exit_status: bolt_result.first['result']['exit_code'],
+                              stdout: bolt_result.first['result']['stdout'],
+                              stderr: bolt_result.first['result']['stderr'])
+      span.add_field('litmus.result', result.to_h)
       yield result if block_given?
-      span.add_field('litmus_runshellsuccess', result)
       result
     end
   end
@@ -151,52 +187,64 @@ module PuppetLitmus::PuppetHelpers
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the command.
   def bolt_upload_file(source, destination, opts = {}, options = {})
-    Honeycomb.start_span(name: 'litmus_uploadfile') do |span|
+    Honeycomb.start_span(name: 'litmus.bolt_upload_file') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.source', source)
+      span.add_field('litmus.destination', destination)
+      span.add_field('litmus.opts', opts)
+      span.add_field('litmus.options', options)
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.node_name', target_node_name)
+      span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+      bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', bolt_result)
       result_obj = {
         exit_code: 0,
-        stdout: result.first['result']['_output'],
+        stdout: bolt_result.first['result']['_output'],
         stderr: nil,
-        result: result.first['result'],
+        result: bolt_result.first['result'],
       }
-      if result.first['status'] != 'success'
+      if bolt_result.first['status'] != 'success'
         if opts[:expect_failures] != true
-          span.add_field('litmus_uploadfilefailure', result)
-          raise "upload file failed\n======\n#{result}"
+          span.add_field('litmus_uploadfilefailure', bolt_result)
+          raise "upload file failed\n======\n#{bolt_result}"
         end
         result_obj[:exit_code] = 255
-        result_obj[:stderr]    = result.first['result']['_error']['msg']
+        result_obj[:stderr]    = bolt_result.first['result']['_error']['msg']
       end
       result = OpenStruct.new(exit_code: result_obj[:exit_code],
                               stdout: result_obj[:stdout],
                               stderr: result_obj[:stderr])
+      span.add_field('litmus.result', result.to_h)
       yield result if block_given?
-      span.add_field('litmus_uploadfilesucess', result)
       result
     end
   end
-  # rubocop:disable Layout/TrailingWhitespace
   # Runs a task against the target system.
   #
   # @param task_name [String] The name of the task to run.
   # @param params [Hash] key : value pairs to be passed to the task.
-  # @param opts [Hash] Alters the behaviour of the command. Valid options are
-  #  :expect_failures [Boolean] doesnt return an exit code of non-zero if the command failed.
+  # @param opts [Hash] Alters the behaviour of the command. Valid options are
+  #  :expect_failures [Boolean] doesnt return an exit code of non-zero if the command failed.
   #  :inventory_file [String] path to the inventory file to use with the task.
   # @return [Object] A result object from the task.The values available are stdout, stderr and result.
-  # rubocop:enable Layout/TrailingWhitespace
   def run_bolt_task(task_name, params = {}, opts = {})
-    Honeycomb.start_span(name: 'litmus_runtask') do |span|
+    Honeycomb.start_span(name: 'litmus.run_task') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.task_name', task_name)
+      span.add_field('litmus.params', params)
+      span.add_field('litmus.opts', opts)
       config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = if !opts[:inventory_file].nil? && File.exist?(opts[:inventory_file])
@@ -208,34 +256,37 @@ module PuppetLitmus::PuppetHelpers
                        end
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
+      span.add_field('litmus.node_name', target_node_name)
+      span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+      bolt_result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
       result_obj = {
         exit_code: 0,
         stdout: nil,
         stderr: nil,
-        result: result.first['result'],
+        result: bolt_result.first['result'],
       }
-      if result.first['status'] == 'success'
+      if bolt_result.first['status'] == 'success'
         # stdout returns unstructured data if structured data is not available
-        result_obj[:stdout] = if result.first['result']['_output'].nil?
-                                result.first['result'].to_s
+        result_obj[:stdout] = if bolt_result.first['result']['_output'].nil?
+                                bolt_result.first['result'].to_s
                               else
-                                result.first['result']['_output']
+                                bolt_result.first['result']['_output']
                               end
       else
         if opts[:expect_failures] != true
-          span.add_field('litmus_runtaskfailure', result)
-          raise "task failed\n`#{task_name}`\n======\n#{result}"
+          span.add_field('litmus_runtaskfailure', bolt_result)
+          raise "task failed\n`#{task_name}`\n======\n#{bolt_result}"
         end
-        result_obj[:exit_code] = if result.first['result']['_error']['details'].nil?
+        result_obj[:exit_code] = if bolt_result.first['result']['_error']['details'].nil?
                                    255
                                  else
-                                   result.first['result']['_error']['details'].fetch('exitcode', 255)
+                                   bolt_result.first['result']['_error']['details'].fetch('exitcode', 255)
                                  end
-        result_obj[:stderr]    = result.first['result']['_error']['msg']
+        result_obj[:stderr]    = bolt_result.first['result']['_error']['msg']
       end
       result = OpenStruct.new(exit_code: result_obj[:exit_code],
@@ -243,7 +294,7 @@ module PuppetLitmus::PuppetHelpers
                               stderr: result_obj[:stderr],
                               result: result_obj[:result])
       yield result if block_given?
-      span.add_field('litmus_runtasksuccess', result)
+      span.add_field('litmus.result', result.to_h)
       result
     end
   end
@@ -256,23 +307,31 @@ module PuppetLitmus::PuppetHelpers
   # @yieldreturn [Block] this method will yield to a block of code passed by the caller; this can be used for additional validation, etc.
   # @return [Object] A result object from the script run.
   def bolt_run_script(script, opts = {}, arguments: [])
-    Honeycomb.start_span(name: 'litmus_runscript') do |span|
+    Honeycomb.start_span(name: 'litmus.bolt_run_script') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.script', script)
+      span.add_field('litmus.opts', opts)
+      span.add_field('litmus.arguments', arguments)
       target_node_name = targeting_localhost? ? 'litmus_localhost' : ENV['TARGET_HOST']
       inventory_hash = File.exist?('inventory.yaml') ? inventory_hash_from_inventory_file : localhost_inventory_hash
       raise "Target '#{target_node_name}' not found in inventory.yaml" unless target_in_inventory?(inventory_hash, target_node_name)
-      result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.node_name', target_node_name)
+      span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+      bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
-      if result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
-        span.add_field('litmus_runscriptfailure', result)
-        raise "script run failed\n`#{script}`\n======\n#{result}"
+      if bolt_result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
+        span.add_field('litmus_runscriptfailure', bolt_result)
+        raise "script run failed\n`#{script}`\n======\n#{bolt_result}"
       end
-      result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
-                              stdout: result.first['result']['stdout'],
-                              stderr: result.first['result']['stderr'])
+      result = OpenStruct.new(exit_code: bolt_result.first['result']['exit_code'],
+                              stdout: bolt_result.first['result']['stdout'],
+                              stderr: bolt_result.first['result']['stderr'])
       yield result if block_given?
-      span.add_field('litmus_runscriptsuccess', result)
+      span.add_field('litmus.result', result.to_h)
       result
     end
   end
@@ -289,14 +348,14 @@ module PuppetLitmus::PuppetHelpers
   # Report an error in the puppet run
   #
   # @param command [String] The puppet command causing the error.
-  # @param result  [Array] The result struct containing the result
-  def report_puppet_apply_error(command, result, acceptable_exit_codes)
+  # @param bolt_result  [Array] The result object from bolt
+  def report_puppet_apply_error(command, bolt_result, acceptable_exit_codes)
     puppet_apply_error = <<~ERROR
       apply manifest failed
       `#{command}`
-      with exit code #{result.first['result']['exit_code']} (expected: #{acceptable_exit_codes})
+      with exit code #{bolt_result.first['result']['exit_code']} (expected: #{acceptable_exit_codes})
       ====== Start output of failed Puppet apply ======
-      #{puppet_output(result)}
+      #{puppet_output(bolt_result)}
       ====== End output of failed Puppet apply ======
     ERROR
     raise puppet_apply_error
@@ -305,22 +364,22 @@ module PuppetLitmus::PuppetHelpers
   # Report an unexpected change in the puppet run
   #
   # @param command [String] The puppet command causing the error.
-  # @param result  [Array] The result struct containing the result
-  def report_puppet_apply_change(command, result)
+  # @param bolt_result  [Array] The result object from bolt
+  def report_puppet_apply_change(command, bolt_result)
     puppet_apply_changes = <<~ERROR
       apply manifest expected no changes
       `#{command}`
       ====== Start output of Puppet apply with unexpected changes ======
-      #{puppet_output(result)}
+      #{puppet_output(bolt_result)}
       ====== End output of Puppet apply with unexpected changes ======
     ERROR
     raise puppet_apply_changes
   end
   # Return the stdout of the puppet run
-  def puppet_output(result)
-    result.dig(0, 'result', 'stderr').to_s << \
-      result.dig(0, 'result', 'stdout').to_s
+  def puppet_output(bolt_result)
+    bolt_result.dig(0, 'result', 'stderr').to_s << \
+      bolt_result.dig(0, 'result', 'stdout').to_s
   end
   # Checks a puppet return status and returns true if it both

data/lib/puppet_litmus/rake_helper.rb CHANGED Viewed

@@ -2,10 +2,43 @@
 module PuppetLitmus; end # rubocop:disable Style/Documentation
+require 'honeycomb-beeline'
+Honeycomb.configure do |config|
+end
+process_span = Honeycomb.start_span(name: 'Litmus Testing', serialized_trace: ENV['HTTP_X_HONEYCOMB_TRACE'])
+ENV['HTTP_X_HONEYCOMB_TRACE'] = process_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+Honeycomb.add_field_to_trace('litmus.pid', Process.pid)
+if ENV['CI'] == 'true' && ENV['TRAVIS'] == 'true'
+  Honeycomb.add_field_to_trace('module_name', ENV['TRAVIS_REPO_SLUG'])
+  Honeycomb.add_field_to_trace('ci.provider', 'travis')
+  Honeycomb.add_field_to_trace('ci.build_id', ENV['TRAVIS_BUILD_ID'])
+  Honeycomb.add_field_to_trace('ci.build_url', ENV['TRAVIS_BUILD_WEB_URL'])
+  Honeycomb.add_field_to_trace('ci.job_url', ENV['TRAVIS_JOB_WEB_URL'])
+  Honeycomb.add_field_to_trace('ci.commit_message', ENV['TRAVIS_COMMIT_MESSAGE'])
+  Honeycomb.add_field_to_trace('ci.sha', ENV['TRAVIS_PULL_REQUEST_SHA'] || ENV['TRAVIS_COMMIT'])
+elsif ENV['CI'] == 'True' && ENV['APPVEYOR'] == 'True'
+  Honeycomb.add_field_to_trace('module_name', ENV['APPVEYOR_PROJECT_SLUG'])
+  Honeycomb.add_field_to_trace('ci.provider', 'appveyor')
+  Honeycomb.add_field_to_trace('ci.build_id', ENV['APPVEYOR_BUILD_ID'])
+  Honeycomb.add_field_to_trace('ci.build_url', "https://ci.appveyor.com/project/#{ENV['APPVEYOR_REPO_NAME']}/builds/#{ENV['APPVEYOR_BUILD_ID']}")
+  Honeycomb.add_field_to_trace('ci.job_url', "https://ci.appveyor.com/project/#{ENV['APPVEYOR_REPO_NAME']}/build/job/#{ENV['APPVEYOR_JOB_ID']}")
+  Honeycomb.add_field_to_trace('ci.commit_message', ENV['APPVEYOR_REPO_COMMIT_MESSAGE'])
+  Honeycomb.add_field_to_trace('ci.sha', ENV['APPVEYOR_PULL_REQUEST_HEAD_COMMIT'] || ENV['APPVEYOR_REPO_COMMIT'])
+elsif ENV['GITHUB_ACTIONS'] == 'true'
+  Honeycomb.add_field_to_trace('module_name', ENV['GITHUB_REPOSITORY'])
+  Honeycomb.add_field_to_trace('ci.provider', 'github')
+  Honeycomb.add_field_to_trace('ci.build_id', ENV['GITHUB_RUN_ID'])
+  Honeycomb.add_field_to_trace('ci.build_url', "https://github.com/#{ENV['GITHUB_REPOSITORY']}/actions/runs/#{ENV['GITHUB_RUN_ID']}")
+  Honeycomb.add_field_to_trace('ci.sha', ENV['GITHUB_SHA'])
+end
+at_exit do
+  process_span.send
+end
 # helper methods for the litmus rake tasks
 module PuppetLitmus::RakeHelper
   DEFAULT_CONFIG_DATA ||= { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }.freeze
-  VALID_PROVISIONERS ||= %w[abs docker docker_exp vagrant vmpooler].freeze
+  SUPPORTED_PROVISIONERS ||= %w[abs docker docker_exp vagrant vmpooler].freeze
   # Gets a string representing the operating system and version.
   #
@@ -52,12 +85,18 @@ module PuppetLitmus::RakeHelper
   # @param command [String] command to execute.
   # @return [Object] the standard out stream.
   def run_local_command(command)
-    require 'open3'
-    stdout, stderr, status = Open3.capture3(command)
-    error_message = "Attempted to run\ncommand:'#{command}'\nstdout:#{stdout}\nstderr:#{stderr}"
-    raise error_message unless status.to_i.zero?
+    Honeycomb.start_span(name: 'litmus.run_local_command') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.command', command)
+      require 'open3'
+      stdout, stderr, status = Open3.capture3(command)
+      error_message = "Attempted to run\ncommand:'#{command}'\nstdout:#{stdout}\nstderr:#{stderr}"
-    stdout
+      raise error_message unless status.to_i.zero?
+      stdout
+    end
   end
   # Builds all the modules in a specified module
@@ -89,16 +128,22 @@ module PuppetLitmus::RakeHelper
     raise "the provision module was not found in #{DEFAULT_CONFIG_DATA['modulepath']}, please amend the .fixtures.yml file" unless
       File.directory?(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
-    unless VALID_PROVISIONERS.include?(provisioner)
-      raise "Unknown provisioner '#{provisioner}', try #{VALID_PROVISIONERS.join('/')}"
-    end
+    params = { 'action' => 'provision', 'platform' => platform, 'inventory' => Dir.pwd }
+    params['vars'] = inventory_vars unless inventory_vars.nil?
+    Honeycomb.add_field_to_trace('litmus.provisioner', provisioner)
+    Honeycomb.start_span(name: 'litmus.provision') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.platform', platform)
+      span.add_field('litmus.inventory', params['inventory'])
+      span.add_field('litmus.config', DEFAULT_CONFIG_DATA)
-    params = if inventory_vars.nil?
-               { 'action' => 'provision', 'platform' => platform, 'inventory' => Dir.pwd }
-             else
-               { 'action' => 'provision', 'platform' => platform, 'inventory' => Dir.pwd, 'vars' => inventory_vars }
-             end
-    run_task("provision::#{provisioner}", 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      bolt_result = run_task(provisioner_task(provisioner), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      span.add_field('litmus.node_name', bolt_result&.first&.dig('result', 'node_name'))
+      bolt_result
+    end
   end
   def provision_list(provision_hash, key)
@@ -107,6 +152,8 @@ module PuppetLitmus::RakeHelper
     # Splat the params into environment variables to pass to the provision task but only in this runspace
     provision_hash[key]['params']&.each { |k, value| ENV[k.upcase] = value.to_s }
     results = []
+    Honeycomb.current_span.add_field('litmus.images', provision_hash[key]['images'])
     provision_hash[key]['images'].each do |image|
       results << provision(provisioner, image, inventory_vars)
     end
@@ -114,42 +161,60 @@ module PuppetLitmus::RakeHelper
   end
   def tear_down_nodes(targets, inventory_hash)
-    require 'bolt_spec/run'
-    include BoltSpec::Run
-    config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
-    raise "the provision module was not found in #{config_data['modulepath']}, please amend the .fixtures.yml file" unless File.directory?(File.join(config_data['modulepath'], 'provision'))
+    Honeycomb.start_span(name: 'litmus.tear_down_nodes') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.targets', targets)
+      require 'bolt_spec/run'
+      include BoltSpec::Run
+      config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
+      raise "the provision module was not found in #{config_data['modulepath']}, please amend the .fixtures.yml file" unless File.directory?(File.join(config_data['modulepath'], 'provision'))
-    results = {}
-    targets.each do |node_name|
-      next if node_name == 'litmus_localhost'
+      results = {}
+      targets.each do |node_name|
+        next if node_name == 'litmus_localhost'
-      result = tear_down(node_name, inventory_hash)
-      results[node_name] = result unless result == []
+        result = tear_down(node_name, inventory_hash)
+        results[node_name] = result unless result == []
+      end
+      results
     end
-    results
   end
   def tear_down(node_name, inventory_hash)
-    # how do we know what provisioner to use
-    node_facts = facts_from_node(inventory_hash, node_name)
-    return [] unless VALID_PROVISIONERS.include?(node_facts['provisioner'])
+    Honeycomb.start_span(name: 'litmus.tear_down') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      # how do we know what provisioner to use
+      node_facts = facts_from_node(inventory_hash, node_name)
-    params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
-    run_task("provision::#{node_facts['provisioner']}", 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      span.add_field('litmus.node_name', node_name)
+      span.add_field('litmus.platform', node_facts['platform'])
+      params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
+      run_task(provisioner_task(node_facts['provisioner']), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+    end
   end
   def install_agent(collection, targets, inventory_hash)
-    require 'bolt_spec/run'
-    include BoltSpec::Run
-    params = if collection.nil?
-               {}
-             else
-               { 'collection' => collection }
-             end
-    raise "puppet_agent was not found in #{DEFAULT_CONFIG_DATA['modulepath']}, please amend the .fixtures.yml file" unless File.directory?(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent'))
-    # using boltspec, when the runner is called it changes the inventory_hash dropping the version field. The clone works around this
-    run_task('puppet_agent::install', targets, params, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash.clone)
+    Honeycomb.start_span(name: 'litmus.install_agent') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.collection', collection)
+      span.add_field('litmus.targets', targets)
+      require 'bolt_spec/run'
+      include BoltSpec::Run
+      params = if collection.nil?
+                 {}
+               else
+                 Honeycomb.current_span.add_field('litmus.collection', collection)
+                 { 'collection' => collection }
+               end
+      raise "puppet_agent was not found in #{DEFAULT_CONFIG_DATA['modulepath']}, please amend the .fixtures.yml file" \
+       unless File.directory?(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent'))
+      # using boltspec, when the runner is called it changes the inventory_hash dropping the version field. The clone works around this
+      run_task('puppet_agent::install', targets, params, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash.clone)
+    end
   end
   def configure_path(inventory_hash)
@@ -190,7 +255,13 @@ module PuppetLitmus::RakeHelper
                     end
     run_local_command("bundle exec bolt file upload \"#{module_tar}\" /tmp/#{File.basename(module_tar)} --nodes #{target_string} --inventoryfile inventory.yaml")
     install_module_command = "puppet module install /tmp/#{File.basename(module_tar)}"
-    run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash)
+    Honeycomb.start_span(name: 'install_module') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      span.add_field('litmus.install_module_command', install_module_command)
+      span.add_field('litmus.target_nodes', target_nodes)
+      run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash)
+    end
   end
   def metadata_module_name
@@ -213,16 +284,36 @@ module PuppetLitmus::RakeHelper
   end
   def check_connectivity?(inventory_hash, target_node_name)
-    require 'bolt_spec/run'
-    include BoltSpec::Run
-    target_nodes = find_targets(inventory_hash, target_node_name)
-    results = run_command('cd .', target_nodes, config: nil, inventory: inventory_hash)
-    failed = []
-    results.each do |result|
-      failed.push(result['target']) if result['status'] == 'failure'
+    Honeycomb.start_span(name: 'litmus.check_connectivity') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      # if we're only checking connectivity for a single node
+      if target_node_name
+        span.add_field('litmus.node_name', target_node_name)
+        span.add_field('litmus.platform', facts_from_node(inventory_hash, target_node_name)['platform'])
+      end
+      require 'bolt_spec/run'
+      include BoltSpec::Run
+      target_nodes = find_targets(inventory_hash, target_node_name)
+      results = run_command('cd .', target_nodes, config: nil, inventory: inventory_hash)
+      span.add_field('litmus.bolt_result', results)
+      failed = []
+      results.each do |result|
+        failed.push(result['target']) if result['status'] == 'failure'
+      end
+      span.add_field('litmus.connectivity_failed', failed)
+      raise "Connectivity has failed on: #{failed}" unless failed.length.zero?
+      true
     end
-    raise "Connectivity has failed on: #{failed}" unless failed.length.zero?
+  end
-    true
+  def provisioner_task(provisioner)
+    if SUPPORTED_PROVISIONERS.include?(provisioner)
+      "provision::#{provisioner}"
+    else
+      warn "WARNING: Unsuported provisioner '#{provisioner}', try #{SUPPORTED_PROVISIONERS.join('/')}"
+      provisioner.to_s
+    end
   end
 end

data/lib/puppet_litmus/rake_tasks.rb CHANGED Viewed

@@ -339,7 +339,7 @@ namespace :litmus do
         payloads = []
         # Generate list of targets to provision
         targets.each do |target|
-          test = 'bundle exec rspec ./spec/acceptance --format progress'
+          test = 'bundle exec rspec ./spec/acceptance --format progress --require rspec_honeycomb_formatter --format RSpecHoneycombFormatter'
           title = "#{target}, #{facts_from_node(inventory_hash, target)['platform']}"
           options = {
             env: {
@@ -366,6 +366,7 @@ namespace :litmus do
           require 'parallel'
           results = Parallel.map(payloads) do |title, test, options|
             env = options[:env].nil? ? {} : options[:env]
+            ENV['HTTP_X_HONEYCOMB_TRACE'] = Honecomb.current_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
             stdout, stderr, status = Open3.capture3(env, test)
             ["\n================\n#{title}\n", stdout, stderr, status]
           end
@@ -384,6 +385,7 @@ namespace :litmus do
           payloads.each do |title, test, options|
             env = options[:env].nil? ? {} : options[:env]
             spinners.register("[:spinner] #{title}") do |sp|
+              ENV['HTTP_X_HONEYCOMB_TRACE'] = Honecomb.current_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
               stdout, stderr, status = Open3.capture3(env, test)
               if status.to_i.zero?
                 sp.success

data/lib/puppet_litmus/version.rb CHANGED Viewed

@@ -2,5 +2,5 @@
 # version of this gem
 module PuppetLitmus
-  VERSION ||= '0.16.0'
+  VERSION ||= '0.17.0'
 end

data/spec/lib/puppet_litmus/puppet_helpers_spec.rb CHANGED Viewed

@@ -3,6 +3,10 @@
 require 'spec_helper'
 RSpec.describe PuppetLitmus::PuppetHelpers do
+  let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'targets' => [{ 'uri' => 'some.host', 'config' => { 'transport' => 'local' }, 'facts' => facts_hash }] }] } }
+  let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'targets' => [{ 'uri' => 'litmus_localhost', 'config' => { 'transport' => 'local' }, 'facts' => facts_hash }] }] } }
+  let(:facts_hash) { { 'provisioner' => 'docker', 'container_name' => 'litmusimage_debian_10-2222', 'platform' => 'litmusimage/debian:10' } }
   context 'with idempotent_apply' do
     let(:manifest) do
       "include '::doot'"
@@ -19,7 +23,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
   describe '.apply_manifest' do
     context 'when specifying a hiera config' do
       let(:manifest) { "include '::doot'" }
-      let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
       let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
       let(:command) { " puppet apply /bla.pp --modulepath #{Dir.pwd}/spec/fixtures/modules --hiera_config='/hiera.yaml'" }
@@ -35,7 +38,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     context 'when using detailed-exitcodes' do
       let(:manifest) { "include '::doot'" }
-      let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
       let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
       let(:command) { " puppet apply /bla.pp --modulepath #{Dir.pwd}/spec/fixtures/modules --detailed-exitcodes" }
@@ -85,8 +87,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
   describe '.run_shell' do
     let(:command_to_run) { "puts 'doot'" }
     let(:result) { ['result' => { 'exit_code' => 0, 'exit_status' => 0, 'stdout' => nil, 'stderr' => nil }] }
-    let(:inventory_hash) { { 'groups' => [{ 'name' => 'ssh_nodes', 'nodes' => [{ 'name' => 'some.host' }] }] } }
-    let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
     it 'responds to run_shell' do
       expect(described_class).to respond_to(:run_shell).with(1..2).arguments
@@ -123,8 +123,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     let(:result_success) {[{'node'=>'some.host','target'=>'some.host','action'=>'upload','object'=>'C:\foo\bar.ps1','status'=>'success','result'=>{'_output'=>'Uploaded \'C:\foo\bar.ps1\' to \'some.host:C:\bar\''}}]}
     let(:result_failure) {[{'node'=>'some.host','target'=>'some.host','action'=>nil,'object'=>nil,'status'=>'failure','result'=>{'_error'=>{'kind'=>'puppetlabs.tasks/task_file_error','msg'=>'No such file or directory @ rb_sysopen - /nonexistant/file/path','details'=>{},'issue_code'=>'WRITE_ERROR'}}}]}
     # rubocop:enable Layout/SpaceInsideHashLiteralBraces, Layout/SpaceInsideBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
-    let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'some.host', 'config' => { 'transport' => 'local' } }] }] } }
-    let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
     it 'responds to run_shell' do
       expect(described_class).to respond_to(:bolt_upload_file).with(2..3).arguments
@@ -177,8 +175,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
   describe '.bolt_run_script' do
     let(:script) { '/tmp/script.sh' }
     let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
-    let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'some.host', 'config' => { 'transport' => 'local' } }] }] } }
-    let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
     it 'responds to bolt_run_script' do
       expect(described_class).to respond_to(:bolt_run_script).with(1..2).arguments
@@ -200,9 +196,9 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does bolt_run_script against remote host without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file)
+        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
         expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: nil).and_return(result)
+        expect(described_class).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: inventory_hash).and_return(result)
         expect { described_class.bolt_run_script(script) }.not_to raise_error
       end
     end
@@ -230,7 +226,6 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     let(:result_structured_task_success){ [{'node'=>'some.host','target'=>'some.host','action'=>'task','object'=>'testtask::structured','status'=>'success','result'=>{'key1'=>'foo','key2'=>'bar'}}]}
     let(:result_failure) {[{'node'=>'some.host','target'=>'some.host','action'=>'task','object'=>'testtask::unstructured','status'=>'failure','result'=>{'_error'=>{'msg'=>'FAILURE!','kind'=>'puppetlabs.tasks/task-error','details'=>{'exitcode'=>123}}}}]}
     # rubocop:enable Layout/SpaceInsideHashLiteralBraces, Layout/SpaceBeforeBlockBraces, Layout/SpaceInsideBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
-    let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'some.host', 'config' => { 'transport' => 'local' } }] }] } }
     it 'responds to bolt_run_task' do
       expect(described_class).to respond_to(:run_bolt_task).with(2..3).arguments

data/spec/lib/puppet_litmus/rake_helper_spec.rb CHANGED Viewed

@@ -2,6 +2,27 @@
 require 'spec_helper'
+RSpec.shared_examples 'supported provisioner' do |args|
+  let(:provisioner) { args[:provisioner] }
+  let(:platform) { args[:platform] }
+  let(:inventory_vars) { args[:inventory_vars] }
+  let(:provision_hash) { args[:provision_hash] }
+  let(:results) { args[:results] }
+  let(:params) { args[:params] }
+  it 'calls function' do
+    allow(File).to receive(:directory?).and_call_original
+    allow(File).to receive(:directory?)
+      .with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
+      .and_return(true)
+    allow_any_instance_of(BoltSpec::Run).to receive(:run_task)
+      .with("provision::#{provisioner}", 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      .and_return(results)
+    result = described_class.provision(provisioner, platform, inventory_vars)
+    expect(result).to eq(results)
+  end
+end
 RSpec.describe PuppetLitmus::RakeHelper do
   context 'with provision_list' do
     let(:provision_hash) { { 'default' => { 'provisioner' => 'docker', 'images' => ['waffleimage/centos7'] } } }
@@ -14,15 +35,29 @@ RSpec.describe PuppetLitmus::RakeHelper do
   end
   context 'with provision' do
-    let(:provision_hash) { { 'default' => { 'provisioner' => 'docker', 'images' => ['waffleimage/centos7'] } } }
-    let(:results) { [] }
-    let(:params) { { 'action' => 'provision', 'platform' => 'waffleimage/centos7', 'inventory' => Dir.pwd } }
-    it 'calls function' do
-      allow(File).to receive(:directory?).and_call_original
-      allow(File).to receive(:directory?).with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
-      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('provision::docker', 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil).and_return(results)
-      described_class.provision('docker', 'waffleimage/centos7', nil)
+    examples = [
+      {
+        provisioner: 'docker',
+        platform: 'waffleimage/centos7',
+        inventory_vars: nil,
+        provision_hash: { 'default' => { 'provisioner' => 'docker', 'images' => ['waffleimage/centos7'] } },
+        results: [],
+        params: { 'action' => 'provision', 'platform' => 'waffleimage/centos7', 'inventory' => Dir.pwd },
+      },
+      {
+        provisioner: 'vagrant',
+        platform: 'centos7',
+        inventory_vars: nil,
+        provision_hash: { 'default' => { 'provisioner' => 'vagrant', 'images' => ['centos7'] } },
+        results: [],
+        params: { 'action' => 'provision', 'platform' => 'centos7', 'inventory' => Dir.pwd },
+      },
+    ].freeze
+    examples.each do |e|
+      describe e[:provisioner] do
+        it_behaves_like 'supported provisioner', e
+      end
     end
   end
@@ -89,12 +124,12 @@ RSpec.describe PuppetLitmus::RakeHelper do
     it 'node available' do
       allow(Open3).to receive(:capture3).with('cd .').and_return(['success', '', 0])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(command, targets, config: nil, inventory: inventory_hash).and_return([{ 'target' => 'some.host', 'status' => 'success' }])
-      described_class.check_connectivity?(inventory_hash, nil)
+      described_class.check_connectivity?(inventory_hash, 'some.host')
     end
     it 'node unavailable' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(command, targets, config: nil, inventory: inventory_hash).and_return([{ 'target' => 'some.host', 'status' => 'failure' }])
-      expect { described_class.check_connectivity?(inventory_hash, nil) }.to raise_error(RuntimeError, %r{Connectivity has failed on:})
+      expect { described_class.check_connectivity?(inventory_hash, 'some.host') }.to raise_error(RuntimeError, %r{Connectivity has failed on:})
     end
   end
@@ -129,4 +164,16 @@ RSpec.describe PuppetLitmus::RakeHelper do
       expect(name).to eq('foo-bar')
     end
   end
+  context 'with provisioner_task' do
+    described_class::SUPPORTED_PROVISIONERS.each do |supported_provisioner|
+      it "returns supported provisioner task name for #{supported_provisioner}" do
+        expect(described_class.provisioner_task(supported_provisioner)).to eq("provision::#{supported_provisioner}")
+      end
+    end
+    it 'returns an unsupported provisioner name' do
+      expect(described_class.provisioner_task('my_org::custom_provisioner')).to eql('my_org::custom_provisioner')
+    end
+  end
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet_litmus
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-09 00:00:00.000000000 Z
+date: 2020-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bolt
@@ -126,6 +126,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_honeycomb_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "    Providing a simple command line tool for puppet content creators,
   to enable simple and complex test deployments.\n"
 email:
@@ -173,19 +187,20 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubyforge_project:
+rubygems_version: 2.7.6.2
 signing_key:
 specification_version: 4
 summary: Providing a simple command line tool for puppet content creators, to enable
   simple and complex test deployments.
 test_files:
-- spec/spec_helper.rb
+- spec/data/doot.tar.gz
+- spec/data/inventory.yaml
+- spec/data/jim.yaml
+- spec/lib/puppet_litmus/inventory_manipulation_spec.rb
 - spec/lib/puppet_litmus/rake_tasks_spec.rb
-- spec/lib/puppet_litmus/version_spec.rb
 - spec/lib/puppet_litmus/util_spec.rb
-- spec/lib/puppet_litmus/inventory_manipulation_spec.rb
-- spec/lib/puppet_litmus/rake_helper_spec.rb
+- spec/lib/puppet_litmus/version_spec.rb
 - spec/lib/puppet_litmus/puppet_helpers_spec.rb
-- spec/data/doot.tar.gz
-- spec/data/jim.yaml
-- spec/data/inventory.yaml
+- spec/lib/puppet_litmus/rake_helper_spec.rb
+- spec/spec_helper.rb