puppet_litmus 0.16.0 → 0.17.0

checksums.yaml

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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