puppet_litmus 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b57432738dbfa9e3c83c891565286c43703437df4d4b8f3a1c09431012dd869d
-  data.tar.gz: 7d4213842c29f689b943dea1a89fc1ea5c4cda272a67fad70c2d55a9b74114a8
+  metadata.gz: ffba803cc6b53c4bdb7084bf11be4fac807f3b3cd237c5ddb297dcf6ca3a403d
+  data.tar.gz: 5cdb613f2be957e20a63fc1250b10113e468e162817657f0f987675f2ba7c055
 SHA512:
-  metadata.gz: 01344ef395005540dc7ae2d109b19e6bf94064f0a27031e886c2f114cdaec8c33c6cbcd71c57a0c164b4724cc5014fb17b7b8ddf12220189f2e10bb22ead26b7
-  data.tar.gz: 4f6a4144f1785e618d40560463de94e874d03208c1a35ba2ca3d031752e9791b133466105f45b50e4ef59f0f12a3e0736e606d2140d0e517b63c633a0dd7aae6
+  metadata.gz: ea1fd95a69bfac81b56f94f3ee28b91be2587c501bf24729931c128315e41d5eaf937dce013ee0d63ec7a350469ac32ab0d7711e50411a0e5fe00340dabdd803
+  data.tar.gz: 899ac2b0edb422ccf35c9cdb5f46bec6b2a6a97557dca12ffc994e046ed8cf1e6eec2553865a3c4439b272d1dd29b0111fc24b2e1bb93575cb77fc0bfd7606b1

data/README.md

@@ -24,7 +24,7 @@ Install Litmus as a gem by running ```gem install puppet_litmus```.
 
 ## Documentation
 
-For documentation, see our [Litmus Wiki](https://github.com/puppetlabs/puppet_litmus/wiki).
+For documentation, see our [Litmus Docs Site](https://puppetlabs.github.io/litmus/).
 
 ## Other Resources
 

data/exe/matrix_from_metadata

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# this script creates a build matrix for github actions from the claimed supported platforms in metadata.json
+
+require 'json'
+
+IMAGE_TABLE = {
+  'RedHat-6' => 'rhel-6',
+  'RedHat-7' => 'rhel-7',
+  'RedHat-8' => 'rhel-8',
+  'SLES-12' => 'sles-12',
+  'SLES-15' => 'sles-15',
+  'Windows-2012 R2' => 'windows-2012-r2-core',
+  'Windows-2016' => 'windows-2016',
+  'Windows-2019' => 'windows-2019-core',
+}.freeze
+
+DOCKER_PLATFORMS = [
+  'CentOS-6',
+  'CentOS-7',
+  'CentOS-8',
+  'Debian-10',
+  'Debian-8',
+  'Debian-9',
+  'OracleLinux-6',
+  'OracleLinux-7',
+  'Scientific-6',
+  'Scientific-7',
+  'Ubuntu-14.04',
+  'Ubuntu-16.04',
+  'Ubuntu-18.04',
+  'Ubuntu-20.04',
+].freeze
+
+matrix = {
+  platform: [],
+  collection: %w[
+    puppet5
+    puppet6
+    puppet7-nightly
+  ],
+}
+
+metadata = JSON.parse(File.read('metadata.json'))
+metadata['operatingsystem_support'].sort_by { |a| a['operatingsystem'] }.each do |sup|
+  os = sup['operatingsystem']
+  sup['operatingsystemrelease'].sort_by { |a| a.to_i }.each do |ver|
+    image_key = "#{os}-#{ver}"
+    if IMAGE_TABLE.key? image_key
+      matrix[:platform] << IMAGE_TABLE[image_key]
+    elsif DOCKER_PLATFORMS.include? image_key
+      puts "Expecting #{image_key} test using docker on travis"
+    else
+      puts "::warning::Cannot find image for #{image_key}"
+    end
+  end
+end
+
+puts "::set-output name=matrix::#{JSON.generate(matrix)}"
+
+puts "Created matrix with #{matrix[:platform].length * matrix[:collection].length} cells."

data/lib/puppet_litmus.rb

@@ -4,7 +4,6 @@
 module PuppetLitmus; end
 
 require 'bolt_spec/run'
-require 'puppet_litmus/honeycomb_utils'
 require 'puppet_litmus/inventory_manipulation'
 require 'puppet_litmus/puppet_helpers'
 require 'puppet_litmus/rake_helper'

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -18,7 +18,7 @@ module PuppetLitmus::InventoryManipulation
     raise "There is no inventory file at '#{inventory_full_path}'." unless File.exist?(inventory_full_path)
 
     inventory_hash = YAML.load_file(inventory_full_path)
-    raise "Inventory file is incompatible (version 2 and up). Try the 'bolt project migrate' command." if inventory_hash.dig('version').nil? || (inventory_hash['version'] < 2)
+    raise "Inventory file is incompatible (version 2 and up). Try the 'bolt project migrate' command." if inventory_hash['version'].nil? || (inventory_hash['version'] < 2)
 
     inventory_hash
   end
@@ -50,12 +50,11 @@ module PuppetLitmus::InventoryManipulation
   # @param targets [Array]
   # @return [Array] array of targets.
   def find_targets(inventory_hash, targets)
-    targets = if targets.nil?
-                inventory_hash.to_s.scan(%r{uri"=>"(\S*)"}).flatten
-              else
-                [targets]
-              end
-    targets
+    if targets.nil?
+      inventory_hash.to_s.scan(%r{uri"=>"(\S*)"}).flatten
+    else
+      [targets]
+    end
   end
 
   # Determines if a node_name exists in a group in the inventory_hash.
@@ -235,7 +234,7 @@ module PuppetLitmus::InventoryManipulation
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file
   # @param feature_name [String] feature to locate in the node
-  # node_name [String] node of nodes to limit the search for the node_name in
+  # @param node_name [String] node of nodes to limit the search for the node_name in
   # @return inventory.yaml file with feature removed from the node.
   # @return [Hash] inventory_hash with feature added to node if node_name exists in inventory hash.
   def remove_feature_from_node(inventory_hash, feature_name, node_name)
@@ -257,4 +256,13 @@ module PuppetLitmus::InventoryManipulation
   def write_to_inventory_file(inventory_hash, inventory_full_path)
     File.open(inventory_full_path, 'wb+') { |f| f.write(inventory_hash.to_yaml) }
   end
+
+  # Add the `litmus.platform` with platform information for the target
+  #
+  # @param inventory_hash [Hash] hash of the inventory.yaml file
+  # @param node_name [String] node of nodes to limit the search for the node_name in
+  def add_platform_field(inventory_hash, node_name)
+    facts = facts_from_node(inventory_hash, node_name)
+    Honeycomb.current_span.add_field('litmus.platform', facts&.dig('platform'))
+  end
 end

data/lib/puppet_litmus/puppet_helpers.rb

@@ -9,7 +9,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [Boolean] The result of the 2 apply manifests.
   def idempotent_apply(manifest)
     Honeycomb.start_span(name: 'litmus.idempotent_apply') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       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)
@@ -39,7 +39,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [Object] A result object from the apply.
   def apply_manifest(manifest, opts = {})
     Honeycomb.start_span(name: 'litmus.apply_manifest') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.manifest', manifest)
       span.add_field('litmus.opts', opts)
 
@@ -73,7 +73,7 @@ module PuppetLitmus::PuppetHelpers
       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)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       command_to_run = "#{opts[:prefix_command]} puppet apply #{manifest_file_location}"
       command_to_run += ' --trace' if !opts[:trace].nil? && (opts[:trace] == true)
@@ -117,7 +117,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [String] The path to the location of the manifest.
   def create_manifest_file(manifest)
     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']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.manifest', manifest)
 
       require 'tmpdir'
@@ -133,9 +133,9 @@ module PuppetLitmus::PuppetHelpers
         # transfer to TARGET_HOST
         inventory_hash = inventory_hash_from_inventory_file
         span.add_field('litmus.node_name', target_node_name)
-        PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+        add_platform_field(inventory_hash, target_node_name)
 
-        manifest_file_location = "/tmp/#{File.basename(manifest_file)}"
+        manifest_file_location = 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['value'].to_s unless bolt_result.first['status'] == 'success'
@@ -147,6 +147,42 @@ module PuppetLitmus::PuppetHelpers
     end
   end
 
+  # Writes a string variable to a file on a target node at a specified path.
+  #
+  # @param content [String] String data to write to the file.
+  # @param destination [String] The path on the target node to write the file.
+  # @return [Bool] Success. The file was succesfully writtne on the target.
+  def write_file(content, destination)
+    Honeycomb.start_span(name: 'litmus.write_file') do |span|
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
+      span.add_field('litmus.destination', destination)
+
+      require 'tmpdir'
+      target_node_name = ENV['TARGET_HOST']
+
+      Tempfile.create('litmus') do |tmp_file|
+        tmp_file.write(content)
+        tmp_file.flush
+        if target_node_name.nil? || target_node_name == 'localhost'
+          require 'fileutils'
+          # no need to transfer
+          FileUtils.cp(tmp_file.path, destination)
+        else
+          # transfer to TARGET_HOST
+          inventory_hash = inventory_hash_from_inventory_file
+          span.add_field('litmus.node_name', target_node_name)
+          add_platform_field(inventory_hash, target_node_name)
+
+          bolt_result = upload_file(tmp_file.path, destination, target_node_name, options: {}, config: nil, inventory: inventory_hash)
+          span.add_field('litmus.bolt_result.file_upload', bolt_result)
+          raise bolt_result.first['value'].to_s unless bolt_result.first['status'] == 'success'
+        end
+      end
+
+      true
+    end
+  end
+
   # Runs a command against the target system
   #
   # @param command_to_run [String] The command to execute.
@@ -155,7 +191,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [Object] A result object from the command.
   def run_shell(command_to_run, opts = {})
     Honeycomb.start_span(name: 'litmus.run_shell') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.command_to_run', command_to_run)
       span.add_field('litmus.opts', opts)
 
@@ -164,7 +200,7 @@ module PuppetLitmus::PuppetHelpers
       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)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, 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)
@@ -192,7 +228,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [Object] A result object from the command.
   def bolt_upload_file(source, destination, opts = {}, options = {})
     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']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.source', source)
       span.add_field('litmus.destination', destination)
       span.add_field('litmus.opts', opts)
@@ -203,7 +239,7 @@ module PuppetLitmus::PuppetHelpers
       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)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = upload_file(source, destination, target_node_name, options: options, config: nil, inventory: inventory_hash)
       span.add_field('litmus.bolt_result', bolt_result)
@@ -244,7 +280,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [Object] A result object from the task.The values available are stdout, stderr and result.
   def run_bolt_task(task_name, params = {}, opts = {})
     Honeycomb.start_span(name: 'litmus.run_task') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.task_name', task_name)
       span.add_field('litmus.params', params)
       span.add_field('litmus.opts', opts)
@@ -261,7 +297,7 @@ module PuppetLitmus::PuppetHelpers
       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)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = run_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
       result_obj = {
@@ -312,7 +348,7 @@ module PuppetLitmus::PuppetHelpers
   # @return [Object] A result object from the script run.
   def bolt_run_script(script, opts = {}, arguments: [])
     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']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.script', script)
       span.add_field('litmus.opts', opts)
       span.add_field('litmus.arguments', arguments)
@@ -322,7 +358,7 @@ module PuppetLitmus::PuppetHelpers
       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)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+      add_platform_field(inventory_hash, target_node_name)
 
       bolt_result = run_script(script, target_node_name, arguments, options: opts, config: nil, inventory: inventory_hash)
 
@@ -382,7 +418,7 @@ module PuppetLitmus::PuppetHelpers
 
   # Return the stdout of the puppet run
   def puppet_output(bolt_result)
-    bolt_result.dig(0, 'value', 'stderr').to_s << \
+    bolt_result.dig(0, 'value', 'stderr').to_s + \
       bolt_result.dig(0, 'value', 'stdout').to_s
   end
 

data/lib/puppet_litmus/rake_helper.rb

@@ -2,16 +2,21 @@
 
 require 'bolt_spec/run'
 require 'honeycomb-beeline'
-require 'puppet_litmus/honeycomb_utils'
+require 'puppet_litmus/version'
 Honeycomb.configure do |config|
   # override client if no configuration is provided, so that the pesky libhoney warning about lack of configuration is not shown
   unless ENV['HONEYCOMB_WRITEKEY'] && ENV['HONEYCOMB_DATASET']
     config.client = Libhoney::NullClient.new
   end
 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']
+process_span = Honeycomb.start_span(name: "litmus: #{([$PROGRAM_NAME] + ($ARGV || [])).join(' ')}", serialized_trace: ENV['HTTP_X_HONEYCOMB_TRACE'])
+ENV['HTTP_X_HONEYCOMB_TRACE'] = process_span.to_trace_header
 Honeycomb.add_field_to_trace('litmus.pid', Process.pid)
+if defined? PuppetLitmus::VERSION
+  Honeycomb.add_field_to_trace('litmus.version', PuppetLitmus::VERSION)
+else
+  Honeycomb.add_field_to_trace('litmus.version', 'undefined')
+end
 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')
@@ -43,7 +48,7 @@ end
 module PuppetLitmus::RakeHelper
   # DEFAULT_CONFIG_DATA should be frozen for our safety, but it needs to work around https://github.com/puppetlabs/bolt/pull/1696
   DEFAULT_CONFIG_DATA ||= { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') } # .freeze # rubocop:disable Style/MutableConstant
-  SUPPORTED_PROVISIONERS ||= %w[abs docker docker_exp vagrant vmpooler].freeze
+  SUPPORTED_PROVISIONERS ||= %w[abs docker docker_exp provision_service vagrant vmpooler].freeze
 
   # Gets a string representing the operating system and version.
   #
@@ -91,7 +96,7 @@ module PuppetLitmus::RakeHelper
   # @return [Object] the standard out stream.
   def run_local_command(command)
     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']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.command', command)
 
       require 'open3'
@@ -114,14 +119,14 @@ module PuppetLitmus::RakeHelper
 
     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']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.platform', platform)
       span.add_field('litmus.inventory', params['inventory'])
       span.add_field('litmus.config', DEFAULT_CONFIG_DATA)
 
       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('value', 'node_name'))
+      raise_bolt_errors(bolt_result, "provisioning of #{platform} failed.")
 
       bolt_result
     end
@@ -143,7 +148,7 @@ module PuppetLitmus::RakeHelper
 
   def tear_down_nodes(targets, inventory_hash)
     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']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.targets', targets)
 
       include ::BoltSpec::Run
@@ -163,21 +168,23 @@ module PuppetLitmus::RakeHelper
 
   def tear_down(node_name, inventory_hash)
     Honeycomb.start_span(name: 'litmus.tear_down') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       # how do we know what provisioner to use
 
       span.add_field('litmus.node_name', node_name)
-      PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, node_name)
+      add_platform_field(inventory_hash, node_name)
 
       params = { 'action' => 'tear_down', 'node_name' => node_name, 'inventory' => Dir.pwd }
       node_facts = facts_from_node(inventory_hash, node_name)
-      run_task(provisioner_task(node_facts['provisioner']), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      bolt_result = run_task(provisioner_task(node_facts['provisioner']), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      raise_bolt_errors(bolt_result, "tear_down of #{node_name} failed.")
+      bolt_result
     end
   end
 
   def install_agent(collection, targets, inventory_hash)
     Honeycomb.start_span(name: 'litmus.install_agent') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.collection', collection)
       span.add_field('litmus.targets', targets)
 
@@ -201,81 +208,102 @@ module PuppetLitmus::RakeHelper
   def configure_path(inventory_hash)
     results = []
     # fix the path on ssh_nodes
-    unless inventory_hash['groups'].select { |group| group['name'] == 'ssh_nodes' }.size.zero?
-      results = run_command('echo PATH="$PATH:/opt/puppetlabs/puppet/bin" > /etc/environment',
-                            'ssh_nodes', config: nil, inventory: inventory_hash)
+    unless inventory_hash['groups'].select { |group| group['name'] == 'ssh_nodes' && !group['targets'].empty? }.size.zero?
+      results << run_command('echo PATH="$PATH:/opt/puppetlabs/puppet/bin" > /etc/environment',
+                             'ssh_nodes', config: nil, inventory: inventory_hash)
+    end
+    unless inventory_hash['groups'].select { |group| group['name'] == 'winrm_nodes' && !group['targets'].empty? }.size.zero?
+      results << run_command('[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files\Puppet Labs\Puppet\bin;C:\Program Files (x86)\Puppet Labs\Puppet\bin", "Machine")',
+                             'winrm_nodes', config: nil, inventory: inventory_hash)
     end
     results
   end
 
+  # Build the module in `module_dir` and put the resulting compressed tarball into `target_dir`.
+  #
   # @param opts Hash of options to build the module
   # @param module_dir [String] The path of the module to build. If missing defaults to Dir.pwd
-  # @param target_dir [String] The path the module will be built into. The default is <source_dir>/pkg
+  # @param target_dir [String] The path the module will be built into. The default is <module_dir>/pkg
   # @return [String] The path to the built module
   def build_module(module_dir = nil, target_dir = nil)
     require 'puppet/modulebuilder'
 
-    source_dir = module_dir || Dir.pwd
-    dest_dir = target_dir || File.join(source_dir, 'pkg')
+    module_dir ||= Dir.pwd
+    target_dir ||= File.join(source_dir, 'pkg')
+
+    puts "Building '#{module_dir}' into '#{target_dir}'"
+    builder = Puppet::Modulebuilder::Builder.new(module_dir, target_dir, nil)
 
-    builder = Puppet::Modulebuilder::Builder.new(source_dir, dest_dir, nil)
     # Force the metadata to be read. Raises if metadata could not be found
     _metadata = builder.metadata
 
     builder.build
   end
 
-  def install_module(inventory_hash, target_node_name, module_tar, module_repository = 'https://forgeapi.puppetlabs.com')
+  # Builds all the modules in a specified directory
+  #
+  # @param source_dir [String] the directory to get the modules from
+  # @param target_dir [String] temporary location to store tarballs before uploading. This directory will be cleaned before use. The default is <source_dir>/pkg
+  # @return [Array] an array of module tars' filenames
+  def build_modules_in_dir(source_dir, target_dir = nil)
+    target_dir ||= File.join(Dir.pwd, 'pkg')
+    # remove old build dir if exists, before we build afresh
+    FileUtils.rm_rf(target_dir) if File.directory?(target_dir)
+
+    module_tars = Dir.entries(source_dir).map do |entry|
+      next if ['.', '..'].include? entry
+
+      module_dir = File.join(source_dir, entry)
+      next unless File.directory? module_dir
+
+      build_module(module_dir, target_dir)
+    end
+    module_tars.compact
+  end
+
+  # @deprecated Use `build_modules_in_dir` instead
+  def build_modules_in_folder(source_folder)
+    build_modules_in_dir(source_folder)
+  end
+
+  # Install a specific module tarball to the specified target.
+  # This method installs dependencies using a forge repository.
+  #
+  # @param inventory_hash [Hash] the pre-loaded inventory
+  # @param target_node_name [String] the name of the target where the module should be installed
+  # @param module_tar [String] the filename of the module tarball to upload
+  # @param module_repository [String] the URL for the forge to use for downloading modules. Defaults to the public Forge API.
+  # @param ignore_dependencies [Boolean] flag used to ignore module dependencies defaults to false.
+  # @return a bolt result
+  def install_module(inventory_hash, target_node_name, module_tar, module_repository = nil, ignore_dependencies = false) # rubocop:disable Style/OptionalBooleanParameter
     Honeycomb.start_span(name: 'install_module') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.target_node_name', target_node_name)
       span.add_field('litmus.module_tar', module_tar)
 
-      # make sure the target module is not installed
+      # make sure the module to install is not installed
       # otherwise `puppet module install` might silently skip it
-      uninstall_module(inventory_hash.clone, target_node_name, force: true)
+      module_name = File.basename(module_tar, '.tar.gz').split('-', 3)[0..1].join('-')
+      uninstall_module(inventory_hash.clone, target_node_name, module_name, force: true)
 
       include ::BoltSpec::Run
 
       target_nodes = find_targets(inventory_hash, target_node_name)
       span.add_field('litmus.target_nodes', target_nodes)
-      bolt_result = upload_file(module_tar, "/tmp/#{File.basename(module_tar)}", target_nodes, options: {}, config: nil, inventory: inventory_hash.clone)
+      bolt_result = upload_file(module_tar, File.basename(module_tar), target_nodes, options: {}, config: nil, inventory: inventory_hash.clone)
       raise_bolt_errors(bolt_result, 'Failed to upload module.')
 
-      install_module_command = "puppet module install --module_repository '#{module_repository}' /tmp/#{File.basename(module_tar)}"
+      module_repository_opts = "--module_repository '#{module_repository}'" unless module_repository.nil?
+      install_module_command = "puppet module install #{module_repository_opts} #{File.basename(module_tar)}"
+      install_module_command += ' --ignore-dependencies --force' if ignore_dependencies.to_s.downcase == 'true'
       span.add_field('litmus.install_module_command', install_module_command)
 
       bolt_result = run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash.clone)
-      raise_bolt_errors(bolt_result, "Installation of package #{module_tar} failed.")
+      raise_bolt_errors(bolt_result, "Installation of package #{File.basename(module_tar)} failed.")
       bolt_result
     end
   end
 
-  # Builds all the modules in a specified module
-  #
-  # @param source_folder [String] the folder to get the modules from
-  # @return [Array] an array of module tar's
-  def build_modules_in_folder(source_folder)
-    folder_list = Dir.entries(source_folder).reject { |f| File.directory? f }
-    module_tars = []
-
-    target_dir = File.join(Dir.pwd, 'pkg')
-    # remove old build folder if exists, before we build afresh
-    FileUtils.rm_rf(target_dir) if File.directory?(target_dir)
-
-    folder_list.each do |folder|
-      folder_handle = Dir.open(File.join(source_folder, folder))
-      next if File.symlink?(folder_handle)
-
-      module_dir = folder_handle.path
-
-      # build_module
-      module_tar = build_module(module_dir, target_dir)
-      module_tars.push(File.new(module_tar))
-    end
-    module_tars
-  end
-
   def metadata_module_name
     require 'json'
     raise 'Could not find metadata.json' unless File.exist?(File.join(Dir.pwd, 'metadata.json'))
@@ -286,22 +314,30 @@ module PuppetLitmus::RakeHelper
     metadata['name']
   end
 
+  # Uninstall a module from a specified target
+  # @param inventory_hash [Hash] the pre-loaded inventory
+  # @param target_node_name [String] the name of the target where the module should be uninstalled
+  # @param module_to_remove [String] the name of the module to remove. Defaults to the module under test.
+  # @param opts [Hash] additional options to pass on to `puppet module uninstall`
   def uninstall_module(inventory_hash, target_node_name, module_to_remove = nil, **opts)
     include ::BoltSpec::Run
     module_name = module_to_remove || metadata_module_name
     target_nodes = find_targets(inventory_hash, target_node_name)
     install_module_command = "puppet module uninstall #{module_name}"
     install_module_command += ' --force' if opts[:force]
-    run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash)
+    bolt_result = run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash)
+    # `puppet module uninstall --force` fails if the module is not installed. Ignore errors when force is set
+    raise_bolt_errors(bolt_result, "uninstalling #{module_name} failed.") unless opts[:force]
+    bolt_result
   end
 
   def check_connectivity?(inventory_hash, target_node_name)
     Honeycomb.start_span(name: 'litmus.check_connectivity') do |span|
-      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+      ENV['HTTP_X_HONEYCOMB_TRACE'] = span.to_trace_header
       # if we're only checking connectivity for a single node
       if target_node_name
         span.add_field('litmus.node_name', target_node_name)
-        PuppetLitmus::HoneycombUtils.add_platform_field(inventory_hash, target_node_name)
+        add_platform_field(inventory_hash, target_node_name)
       end
 
       include ::BoltSpec::Run
@@ -331,7 +367,7 @@ module PuppetLitmus::RakeHelper
   # Parse out errors messages in result set returned by Bolt command.
   #
   # @param result_set [Array] result set returned by Bolt command.
-  # @return [Hash] Error messages grouped by target.
+  # @return [Hash] Errors grouped by target.
   def check_bolt_errors(result_set)
     errors = {}
     # iterate through each error
@@ -342,8 +378,7 @@ module PuppetLitmus::RakeHelper
 
       target = target_result['target']
       # get some info from error
-      error_msg = target_result['value']['_error']['msg']
-      errors[target] = error_msg
+      errors[target] = target_result['value']
     end
     errors
   end
@@ -356,7 +391,8 @@ module PuppetLitmus::RakeHelper
     errors = check_bolt_errors(result_set)
 
     unless errors.empty?
-      raise "#{error_msg}\nErrors: #{errors}"
+      formatted_results = errors.map { |k, v| "  #{k}: #{v.inspect}" }.join("\n")
+      raise "#{error_msg}\nResults:\n#{formatted_results}}"
     end
 
     nil