puppet_litmus 0.18.4 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60fc5eef658171b749a429d8d302e94c05e8812858206124e90c915a035a8e4e
-  data.tar.gz: 2016992ffee484e5c2ab2b92e0011d98678b21bc1c0e62dd1d75c857ad50db65
+  metadata.gz: 7c3c6a488e0f0aa8b61b2f1d6678fd54d093aa11693b8ab004f57205f72049c9
+  data.tar.gz: 65ce0b461f8c1b0683f9b608aa08ede12d44794d766d007da423472fbb856535
 SHA512:
-  metadata.gz: f4bb7954ab40c5345dacb291f0fd82a745c7ac5da4e939e07323e23f6c06b7c4758303cc5f9faccf75f67134337ad409edb429ebb438ffe879682460722cacb3
-  data.tar.gz: 3367726403b6691edbb3439377617f894fdffec96f964965bb1e62aa175ade0494920ec166b49da367449c331a9ca6f8e7f87ed2ede707bb7cd7410077e63c38
+  metadata.gz: 2191d39436024913ac79e2e4e1ea16306f4c4ece91c6ff3782a0d67eeda849ccc1079ac8976ed1c7e1edb5d9cb5fd92b86ef1a2f9261cde1134710267e08f29c
+  data.tar.gz: 0661730c8fd0a5e4152840ff84edf917bd76d46691d580981d1d265d957457358aa4afa04ba6f573db9a97dfec2cb10fee74a5638249e4f31e40f7893b21e5f1

data/exe/matrix_from_metadata

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# this script creates a build matrix for github actions from the claimed supported platforms and puppet versions in metadata.json
+
+require 'json'
+
+IMAGE_TABLE = {
+  '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
+
+# This table uses the latest version in each collection for accurate
+# comparison when evaluating puppet requirements from the metadata
+COLLECTION_TABLE = {
+  '5.5.22' => 'puppet5',
+  '6.19.1' => 'puppet6-nightly',
+  '7.0.0' => 'puppet7-nightly',
+}.freeze
+
+matrix = {
+  platform: [],
+  collection: [],
+}
+
+metadata = JSON.parse(File.read('metadata.json'))
+# Set platforms based on declared operating system support
+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
+
+# Set collections based on puppet version requirements
+if metadata.key?('requirements') && metadata['requirements'].length.positive?
+  metadata['requirements'].each do |req|
+    next unless req.key?('name') && req.key?('version_requirement') && req['name'] == 'puppet'
+
+    ver_regexp = %r{^([>=<]{1,2})\s*([\d.]+)\s+([>=<]{1,2})\s*([\d.]+)$}
+    match = ver_regexp.match(req['version_requirement'])
+    if match.nil?
+      puts "::warning::Didn't recognize version_requirement '#{req['version_requirement']}'"
+      break
+    end
+
+    cmp_one, ver_one, cmp_two, ver_two = match.captures
+    reqs = ["#{cmp_one} #{ver_one}", "#{cmp_two} #{ver_two}"]
+
+    COLLECTION_TABLE.each do |key, val|
+      if Gem::Requirement.create(reqs).satisfied_by?(Gem::Version.new(key))
+        matrix[:collection] << val
+      end
+    end
+  end
+end
+
+# Set to defaults (all collections) if no matches are found
+if matrix[:collection].empty?
+  matrix[:collection] = COLLECTION_TABLE.values
+end
+
+# Just to make sure there aren't any duplicates
+matrix[:platform] = matrix[:platform].uniq.sort
+matrix[:collection] = matrix[:collection].uniq.sort
+
+puts "::set-output name=matrix::#{JSON.generate(matrix)}"
+
+puts "Created matrix with #{matrix[:platform].length * matrix[:collection].length} cells."

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -17,10 +17,7 @@ module PuppetLitmus::InventoryManipulation
                           end
     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)
-
-    inventory_hash
+    YAML.load_file(inventory_full_path)
   end
 
   # Provide a default hash for executing against localhost
@@ -28,7 +25,6 @@ module PuppetLitmus::InventoryManipulation
   # @return [Hash] inventory.yaml hash containing only an entry for localhost
   def localhost_inventory_hash
     {
-      'version' => 2,
       'groups' => [
         {
           'name' => 'local',
@@ -50,12 +46,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.
@@ -263,7 +258,12 @@ module PuppetLitmus::InventoryManipulation
   # @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)
+    facts = begin
+      facts_from_node(inventory_hash, node_name)
+    rescue StandardError => e
+      warn e
+      {}
+    end
     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
+      ENV['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)
@@ -30,7 +30,7 @@ module PuppetLitmus::PuppetHelpers
   #  :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.
+  #  :hiera_config [Path] The path to the hiera.yaml configuration on the target.
   #  :prefix_command [String] prefixes the puppet apply command; eg "export LANGUAGE='ja'".
   #  :trace [Boolean] run puppet apply with the trace flag (defaults to `true`).
   #  :debug [Boolean] run puppet apply with the debug flag.
@@ -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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.manifest', manifest)
       span.add_field('litmus.opts', opts)
 
@@ -83,11 +83,22 @@ module PuppetLitmus::PuppetHelpers
       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)
 
+      if os[:family] == 'windows'
+        # IAC-1365 - Workaround for BOLT-1535 and bolt issue #1650
+        command_to_run = "try { #{command_to_run}; exit $LASTEXITCODE } catch { write-error $_ ; exit 1 }"
+        span.add_field('litmus.command_to_run', command_to_run)
+        bolt_result = Tempfile.open(['temp', '.ps1']) do |script|
+          script.write(command_to_run)
+          script.close
+          run_script(script.path, target_node_name, [], options: {}, config: nil, inventory: inventory_hash)
+        end
+      else
+        span.add_field('litmus.command_to_run', command_to_run)
+        bolt_result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+      end
+      span.add_field('litmus.bolt_result', bolt_result)
       result = OpenStruct.new(exit_code: bolt_result.first['value']['exit_code'],
                               stdout: bolt_result.first['value']['stdout'],
                               stderr: bolt_result.first['value']['stderr'])
@@ -117,7 +128,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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.manifest', manifest)
 
       require 'tmpdir'
@@ -147,6 +158,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['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 +202,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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.command_to_run', command_to_run)
       span.add_field('litmus.opts', opts)
 
@@ -192,7 +239,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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.source', source)
       span.add_field('litmus.destination', destination)
       span.add_field('litmus.opts', opts)
@@ -244,7 +291,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
+      ENV['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)
@@ -312,7 +359,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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.script', script)
       span.add_field('litmus.opts', opts)
       span.add_field('litmus.arguments', arguments)
@@ -382,7 +429,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

@@ -9,8 +9,8 @@ Honeycomb.configure do |config|
     config.client = Libhoney::NullClient.new
   end
 end
-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
+process_span = Honeycomb.start_span(name: "litmus: #{([$PROGRAM_NAME] + ($ARGV || [])).join(' ')}", serialized_trace: ENV['HONEYCOMB_TRACE'])
+ENV['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)
@@ -41,6 +41,13 @@ elsif ENV['GITHUB_ACTIONS'] == 'true'
   Honeycomb.add_field_to_trace('ci.sha', ENV['GITHUB_SHA'])
 end
 at_exit do
+  if $ERROR_INFO.is_a?(SystemExit)
+    process_span.add_field('process.exit_code', $ERROR_INFO.status)
+  elsif $ERROR_INFO
+    process_span.add_field('process.exit_code', $ERROR_INFO.class.name)
+  else
+    process_span.add_field('process.exit_code', 'unknown')
+  end
   process_span.send
 end
 
@@ -48,7 +55,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.
   #
@@ -96,7 +103,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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.command', command)
 
       require 'open3'
@@ -119,13 +126,18 @@ 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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.platform', platform)
-      span.add_field('litmus.inventory', params['inventory'])
+
+      task_name = provisioner_task(provisioner)
+      span.add_field('litmus.task_name', task_name)
+      span.add_field('litmus.params', params)
       span.add_field('litmus.config', DEFAULT_CONFIG_DATA)
 
-      bolt_result = run_task(provisioner_task(provisioner), 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      bolt_result = run_task(task_name, 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      span.add_field('litmus.result', bolt_result)
       span.add_field('litmus.node_name', bolt_result&.first&.dig('value', 'node_name'))
+
       raise_bolt_errors(bolt_result, "provisioning of #{platform} failed.")
 
       bolt_result
@@ -148,7 +160,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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.targets', targets)
 
       include ::BoltSpec::Run
@@ -160,6 +172,18 @@ module PuppetLitmus::RakeHelper
         next if node_name == 'litmus_localhost'
 
         result = tear_down(node_name, inventory_hash)
+        # Some provisioners tear_down targets that were created as a batch job.
+        # These provisioners should return the list of additional targets
+        # removed so that we do not attempt to process them.
+        if result != [] && result[0]['value'].key?('removed')
+          removed_targets = result[0]['value']['removed']
+          result[0]['value'].delete('removed')
+          removed_targets.each do |removed_target|
+            targets.delete(removed_target)
+            results[removed_target] = result
+          end
+        end
+
         results[node_name] = result unless result == []
       end
       results
@@ -168,7 +192,7 @@ 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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       # how do we know what provisioner to use
 
       span.add_field('litmus.node_name', node_name)
@@ -184,7 +208,7 @@ module PuppetLitmus::RakeHelper
 
   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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.collection', collection)
       span.add_field('litmus.targets', targets)
 
@@ -192,7 +216,6 @@ module PuppetLitmus::RakeHelper
       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" \
@@ -208,9 +231,13 @@ 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
@@ -227,7 +254,7 @@ module PuppetLitmus::RakeHelper
     module_dir ||= Dir.pwd
     target_dir ||= File.join(source_dir, 'pkg')
 
-    puts "Building '#{module_dir}' into '#{target_dir}''"
+    puts "Building '#{module_dir}' into '#{target_dir}'"
     builder = Puppet::Modulebuilder::Builder.new(module_dir, target_dir, nil)
 
     # Force the metadata to be read. Raises if metadata could not be found
@@ -269,10 +296,11 @@ module PuppetLitmus::RakeHelper
   # @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)
+  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
+      ENV['HONEYCOMB_TRACE'] = span.to_trace_header
       span.add_field('litmus.target_node_name', target_node_name)
       span.add_field('litmus.module_tar', module_tar)
 
@@ -290,6 +318,7 @@ module PuppetLitmus::RakeHelper
 
       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)
@@ -327,24 +356,30 @@ module PuppetLitmus::RakeHelper
 
   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
+      ENV['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)
+        span.add_field('litmus.target_node_name', target_node_name)
         add_platform_field(inventory_hash, target_node_name)
       end
 
       include ::BoltSpec::Run
       target_nodes = find_targets(inventory_hash, target_node_name)
+      puts "Checking connectivity for #{target_nodes.inspect}"
+      span.add_field('litmus.target_nodes', target_nodes)
+
       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'
+      results.reject { |r| r['status'] == 'success' }.each do |result|
+        puts "Failure connecting to #{result['target']}:\n#{result.inspect}"
+        failed.push(result['target'])
       end
-      span.add_field('litmus.connectivity_failed', failed)
+      span.add_field('litmus.connectivity_success', results.select { |r| r['status'] == 'success' })
+      span.add_field('litmus.connectivity_failure', results.reject { |r| r['status'] == 'success' })
       raise "Connectivity has failed on: #{failed}" unless failed.length.zero?
 
+      puts 'Connectivity check PASSED.'
       true
     end
   end
@@ -391,4 +426,50 @@ module PuppetLitmus::RakeHelper
 
     nil
   end
+
+  def start_spinner(message)
+    if (ENV['CI'] || '').downcase == 'true'
+      puts message
+      spinner = Thread.new do
+        # CI systems are strange beasts, we only output a '.' every wee while to keep the terminal alive.
+        loop do
+          printf '.'
+          sleep(10)
+        end
+      end
+    else
+      require 'tty-spinner'
+      spinner = TTY::Spinner.new("[:spinner] #{message}")
+      spinner.auto_spin
+    end
+    spinner
+  end
+
+  def stop_spinner(spinner)
+    if (ENV['CI'] || '').downcase == 'true'
+      Thread.kill(spinner)
+    else
+      spinner.success
+    end
+  end
+
+  require 'retryable'
+
+  Retryable.configure do |config|
+    config.sleep = ->(n) { (1.5**n) + Random.rand(0.5) }
+    # config.log_method = ->(retries, exception) do
+    #   Logger.new($stdout).debug("[Attempt ##{retries}] Retrying because [#{exception.class} - #{exception.message}]: #{exception.backtrace.first(5).join(' | ')}")
+    # end
+  end
+
+  class LitmusTimeoutError < StandardError; end
+
+  def with_retries(options: { tries: Float::INFINITY }, max_wait_minutes: 8)
+    stop = Time.now + (max_wait_minutes * 60)
+    Retryable.retryable(options.merge(not: [LitmusTimeoutError])) do
+      raise LitmusTimeoutError if Time.now > stop
+
+      yield
+    end
+  end
 end

data/lib/puppet_litmus/rake_tasks.rb

@@ -33,35 +33,35 @@ namespace :litmus do
     inventory_vars = provision_hash[args[:key]]['vars']
     # Splat the params into environment variables to pass to the provision task but only in this runspace
     provision_hash[args[:key]]['params']&.each { |k, value| ENV[k.upcase] = value.to_s }
-    results = []
     failed_image_message = ''
-    provision_hash[args[:key]]['images'].each do |image|
-      if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
-        progress = Thread.new do
-          loop do
-            printf '.'
-            sleep(10)
-          end
-        end
-      else
-        require 'tty-spinner'
-        spinner = TTY::Spinner.new("Provisioning #{image} using #{provisioner} provisioner.[:spinner]")
-        spinner.auto_spin
-      end
-      result = provision(provisioner, image, inventory_vars)
-
-      if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
-        Thread.kill(progress)
-      else
-        spinner.success
+    if provision_hash[args[:key]]['images'].instance_of?(Hash)
+      begin
+        spinner = start_spinner("Provisioning multiple images using #{provisioner} provisioner.")
+        result = provision(provisioner, provision_hash[args[:key]]['images'], inventory_vars)
+      ensure
+        stop_spinner(spinner)
       end
 
       if result.first['status'] != 'success'
         failed_image_message += "=====\n#{result.first['target']}\n#{result.first['value']['_output']}\n#{result.inspect}"
       else
-        STDOUT.puts "#{result.first['value']['node_name']}, #{image}"
+        $stdout.puts 'Success'
+      end
+    else
+      provision_hash[args[:key]]['images'].each do |image|
+        begin
+          spinner = start_spinner("Provisioning #{image} using #{provisioner} provisioner.")
+          result = provision(provisioner, image, inventory_vars)
+        ensure
+          stop_spinner(spinner)
+        end
+
+        if result.first['status'] != 'success'
+          failed_image_message += "=====\n#{result.first['target']}\n#{result.first['value']['_output']}\n#{result.inspect}"
+        else
+          $stdout.puts "#{result.first['value']['node_name']}, #{image}"
+        end
       end
-      results << result
     end
 
     raise "Failed to provision with '#{provisioner}'\n #{failed_image_message}" unless failed_image_message.empty?
@@ -74,28 +74,35 @@ namespace :litmus do
   desc 'provision a test system using the given provisioner and platform name. See the puppetlabs-provision module tasks for more documentation'
   task :provision, [:provisioner, :platform, :inventory_vars] do |_task, args|
     Rake::Task['spec_prep'].invoke
-    if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
-      progress = Thread.new do
-        loop do
-          printf '.'
-          sleep(10)
+
+    begin
+      spinner = start_spinner("Provisioning #{args[:platform]} using #{args[:provisioner]} provisioner.")
+
+      results = provision(args[:provisioner], args[:platform], args[:inventory_vars])
+
+      unless results.first['status'] == 'success'
+        raise "Failed provisioning #{args[:platform]} using #{args[:provisioner]}\n#{results.first}"
+      end
+
+      puts "Successfully provisioned #{args[:platform]} using #{args[:provisioner]}\n"
+
+      target_names = if results.first['value']['node']
+                       [results.first['value']['node']['uri']]
+                     else
+                       results.first['value']['target_names'] || [] # provision_service multi-node provisioning
+                     end
+      target_names.each do |target|
+        Honeycomb.start_span(name: 'litmus.provision.check_connectivity') do |span|
+          span.add_field('target_name', target)
+          with_retries do
+            check_connectivity?(inventory_hash_from_inventory_file, target)
+          end
         end
       end
-    else
-      require 'tty-spinner'
-      spinner = TTY::Spinner.new("Provisioning #{args[:platform]} using #{args[:provisioner]} provisioner.[:spinner]")
-      spinner.auto_spin
-    end
-    results = provision(args[:provisioner], args[:platform], args[:inventory_vars])
-    if results.first['status'] != 'success'
-      raise "Failed provisioning #{args[:platform]} using #{args[:provisioner]}\n#{results.first}"
+    ensure
+      stop_spinner(spinner)
     end
 
-    if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
-      Thread.kill(progress)
-    else
-      spinner.success
-    end
     puts "#{results.first['value']['node_name']}, #{args[:platform]}"
   end
 
@@ -118,25 +125,39 @@ namespace :litmus do
 
     results = install_agent(args[:collection], targets, inventory_hash)
     results.each do |result|
-      if result['status'] != 'success'
-        command_to_run = "bolt task run puppet_agent::install --targets #{result['target']} --inventoryfile inventory.yaml --modulepath #{DEFAULT_CONFIG_DATA['modulepath']}"
-        raise "Failed on #{result['target']}\n#{result}\ntry running '#{command_to_run}'"
-      else
-        # add puppet-agent feature to successful nodes
-        inventory_hash = add_feature_to_node(inventory_hash, 'puppet-agent', result['target'])
+      command_to_run = "bolt task run puppet_agent::install --targets #{result['target']} --inventoryfile inventory.yaml --modulepath #{DEFAULT_CONFIG_DATA['modulepath']}"
+      raise "Failed on #{result['target']}\n#{result}\ntry running '#{command_to_run}'" if result['status'] != 'success'
+
+      # validate successful install
+      puts "Successfull install result: #{result.inspect}" if ENV['DEBUG'] == 'true'
+      retries = 0
+      begin
+        responses = run_command('puppet --version', targets, options: {}, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash.clone)
+        responses.each do |response|
+          raise "Error checking puppet version on #{response.to_json}" if response['status'] != 'success'
+        end
+      rescue StandardError => e
+        puts "ERROR:#{e}" if ENV['DEBUG'] == 'true'
+        # fix the path
+        path_changes = configure_path(inventory_hash)
+        if ENV['DEBUG'] == 'true'
+          path_changes.each do |change|
+            puts "Configuring puppet path result: #{change.inspect}"
+          end
+        end
+
+        retries += 1
+        sleep 3
+        retry if retries <= 300
+        raise 'Failed to detect installed puppet version after 5 minutes'
       end
+
+      # add puppet-agent feature to successful nodes
+      inventory_hash = add_feature_to_node(inventory_hash, 'puppet-agent', result['target'])
     end
+
     # update the inventory with the puppet-agent feature set per node
     write_to_inventory_file(inventory_hash, 'inventory.yaml')
-
-    # fix the path on ssh_nodes
-    results = configure_path(inventory_hash)
-
-    results.each do |result|
-      if result['status'] != 'success'
-        puts "Failed on #{result['target']}\n#{result}"
-      end
-    end
   end
 
   # Add a given feature to a selection of nodes
@@ -195,8 +216,8 @@ namespace :litmus do
   # @param :source [String] source directory to look in (ignores symlinks) defaults do './spec/fixtures/modules'.
   # @param :target_node_name [Array] nodes on which to install a puppet module for testing.
   desc 'build and install all modules from a directory'
-  task :install_modules_from_directory, [:source, :target_node_name, :module_repository] do |_task, args|
-    args.with_defaults(source: nil, target_node_name: nil, module_repository: nil)
+  task :install_modules_from_directory, [:source, :target_node_name, :module_repository, :ignore_dependencies] do |_task, args|
+    args.with_defaults(source: nil, target_node_name: nil, module_repository: nil, ignore_dependencies: false)
     inventory_hash = inventory_hash_from_inventory_file
     target_nodes = find_targets(inventory_hash, args[:target_node_name])
     if target_nodes.empty?
@@ -217,7 +238,7 @@ namespace :litmus do
     module_tars.each do |module_tar|
       puts "Installing '#{module_tar}'"
       target_nodes.each do |target_node_name|
-        install_module(inventory_hash, target_node_name, module_tar, args[:module_repository])
+        install_module(inventory_hash, target_node_name, module_tar, args[:module_repository], args[:ignore_dependencies])
         puts "Installed '#{module_tar}' on #{target_node_name}"
       end
     end
@@ -321,15 +342,21 @@ namespace :litmus do
 
       # Run acceptance tests against all machines in the inventory file in parallel.
       desc 'Run tests in parallel against all machines in the inventory file'
-      task :parallel do
+      task :parallel, [:tag] do |_task, args|
+        args.with_defaults(tag: nil)
         if targets.empty?
           puts 'No targets found'
           exit 0
         end
+        tag_value = if args[:tag].nil?
+                      nil
+                    else
+                      "--tag #{args[:tag]}"
+                    end
         payloads = []
         # Generate list of targets to provision
         targets.each do |target|
-          test = 'bundle exec rspec ./spec/acceptance --format progress --require rspec_honeycomb_formatter --format RSpecHoneycombFormatter'
+          test = "bundle exec rspec ./spec/acceptance #{tag_value} --format progress --require rspec_honeycomb_formatter --format RSpecHoneycombFormatter"
           title = "#{target}, #{facts_from_node(inventory_hash, target)['platform']}"
           options = {
             env: {
@@ -343,7 +370,7 @@ namespace :litmus do
         success_list = []
         failure_list = []
         # Provision targets depending on what environment we're in
-        if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
+        if ENV['CI'] == 'true'
           # CI systems are strange beasts, we only output a '.' every wee while to keep the terminal alive.
           puts "Running against #{targets.size} targets.\n"
           progress = Thread.new do
@@ -360,16 +387,16 @@ namespace :litmus do
             at_exit { exit! }
 
             env = options[:env].nil? ? {} : options[:env]
-            env['HTTP_X_HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
+            env['HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
             stdout, stderr, status = Open3.capture3(env, test)
             ["\n================\n#{title}\n", stdout, stderr, status]
           end
           # because we cannot modify variables inside of Parallel
           results.each do |result|
             if result.last.to_i.zero?
-              success_list.push(result.first.scan(%r{.*})[2])
+              success_list.push(result.first.scan(%r{.*})[3])
             else
-              failure_list.push(result.first.scan(%r{.*})[2])
+              failure_list.push(result.first.scan(%r{.*})[3])
             end
           end
           Thread.kill(progress)
@@ -378,7 +405,7 @@ namespace :litmus do
           spinners = TTY::Spinner::Multi.new("[:spinner] Running against #{targets.size} targets.")
           payloads.each do |title, test, options|
             env = options[:env].nil? ? {} : options[:env]
-            env['HTTP_X_HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
+            env['HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
             spinners.register("[:spinner] #{title}") do |sp|
               stdout, stderr, status = Open3.capture3(env, test)
               if status.to_i.zero?
@@ -411,8 +438,9 @@ namespace :litmus do
         desc "Run serverspec against #{target}"
         next if target == 'litmus_localhost'
 
-        RSpec::Core::RakeTask.new(target.to_sym) do |t|
+        RSpec::Core::RakeTask.new(target.to_sym, :tag) do |t, args|
           t.pattern = 'spec/acceptance/**{,/*/**}/*_spec.rb'
+          t.rspec_opts = "--tag #{args[:tag]}" unless args[:tag].nil?
           ENV['TARGET_HOST'] = target
         end
       end
@@ -421,8 +449,9 @@ namespace :litmus do
     # add localhost separately
     desc 'Run serverspec against localhost, USE WITH CAUTION, this action can be potentially dangerous.'
     host = 'localhost'
-    RSpec::Core::RakeTask.new(host.to_sym) do |t|
+    RSpec::Core::RakeTask.new(host.to_sym, :tag) do |t, args|
       t.pattern = 'spec/acceptance/**{,/*/**}/*_spec.rb'
+      t.rspec_opts = "--tag #{args[:tag]}" unless args[:tag].nil?
       Rake::Task['spec_prep'].invoke
       ENV['TARGET_HOST'] = host
     end

data/lib/puppet_litmus/spec_helper_acceptance.rb

@@ -35,6 +35,7 @@ module PuppetLitmus
         options[:port] = node_config.dig('ssh', 'port') unless node_config.dig('ssh', 'port').nil?
         options[:keys] = node_config.dig('ssh', 'private-key') unless node_config.dig('ssh', 'private-key').nil?
         options[:password] = node_config.dig('ssh', 'password') unless node_config.dig('ssh', 'password').nil?
+        run_as = node_config.dig('ssh', 'run-as') unless node_config.dig('ssh', 'run-as').nil?
         # Support both net-ssh 4 and 5.
         # rubocop:disable Metrics/BlockNesting
         options[:verify_host_key] = if node_config.dig('ssh', 'host-key-check').nil?
@@ -67,6 +68,8 @@ module PuppetLitmus
         set :host,        options[:host_name] || host
         set :ssh_options, options
         set :request_pty, false
+        set :sudo_password, options[:password] if run_as
+        puts "Running tests as #{run_as}" if run_as
       elsif target_in_group(inventory_hash, ENV['TARGET_HOST'], 'winrm_nodes')
         require 'winrm'
 

data/lib/puppet_litmus/version.rb

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

data/spec/lib/puppet_litmus/puppet_helpers_spec.rb

@@ -113,10 +113,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     let(:local) { '/tmp' }
     let(:remote) { '/remote_tmp' }
     # Ignore rubocop because these hashes are representative of output from an external method and editing them leads to test failures.
-    # rubocop:disable Layout/SpaceInsideHashLiteralBraces, Layout/SpaceInsideBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
-    let(:result_success) {[{'target'=>'some.host','action'=>'upload','object'=>'C:\foo\bar.ps1','status'=>'success','value'=>{'_output'=>'Uploaded \'C:\foo\bar.ps1\' to \'some.host:C:\bar\''}}]}
-    let(:result_failure) {[{'target'=>'some.host','action'=>nil,'object'=>nil,'status'=>'failure','value'=>{'_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
+    # rubocop:disable Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
+    let(:result_success) { [{ 'target'=>'some.host','action'=>'upload','object'=>'C:\foo\bar.ps1','status'=>'success','value'=>{ '_output'=>'Uploaded \'C:\foo\bar.ps1\' to \'some.host:C:\bar\'' } }] }
+    let(:result_failure) { [{ 'target'=>'some.host','action'=>nil,'object'=>nil,'status'=>'failure','value'=>{ '_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/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
 
     it 'responds to run_shell' do
       expect(self).to respond_to(:bolt_upload_file).with(2..3).arguments
@@ -212,11 +212,11 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     let(:params) { { 'action' => 'install', 'name' => 'foo' } }
     let(:config_data) { { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') } }
     # Ignore rubocop because these hashes are representative of output from an external method and editing them leads to test failures.
-    # rubocop:disable Layout/SpaceInsideHashLiteralBraces, Layout/SpaceBeforeBlockBraces, Layout/SpaceInsideBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
-    let(:result_unstructured_task_success){ [{'target'=>'some.host','action'=>'task','object'=>'testtask::unstructured','status'=>'success','value'=>{'_output'=>'SUCCESS!'}}]}
-    let(:result_structured_task_success){ [{'target'=>'some.host','action'=>'task','object'=>'testtask::structured','status'=>'success','value'=>{'key1'=>'foo','key2'=>'bar'}}]}
-    let(:result_failure) {[{'target'=>'some.host','action'=>'task','object'=>'testtask::unstructured','status'=>'failure','value'=>{'_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
+    # rubocop:disable Layout/SpaceBeforeBlockBraces
+    let(:result_unstructured_task_success){ [{ 'target'=>'some.host','action'=>'task','object'=>'testtask::unstructured','status'=>'success','value'=>{ '_output'=>'SUCCESS!' } }] }
+    let(:result_structured_task_success){ [{ 'target'=>'some.host','action'=>'task','object'=>'testtask::structured','status'=>'success','value'=>{ 'key1'=>'foo','key2'=>'bar' } }] }
+    let(:result_failure) { [{ 'target'=>'some.host','action'=>'task','object'=>'testtask::unstructured','status'=>'failure','value'=>{ '_error'=>{ 'msg'=>'FAILURE!','kind'=>'puppetlabs.tasks/task-error','details'=>{ 'exitcode'=>123 } } } }] }
+    # rubocop:enable Layout/SpaceBeforeBlockBraces, Layout/SpaceAroundOperators, Layout/LineLength, Layout/SpaceAfterComma
 
     it 'responds to bolt_run_task' do
       expect(self).to respond_to(:run_bolt_task).with(2..3).arguments
@@ -286,4 +286,42 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       end
     end
   end
+
+  describe '.write_file' do
+    let(:content) { 'foo' }
+    let(:destination) { '/tmp/foo' }
+    let(:owner) { 'foo:foo' }
+    let(:local_path) { '/tmp/local_foo' }
+
+    before(:each) do
+      allow_any_instance_of(File).to receive(:path).and_return(local_path)
+    end
+
+    it 'responds to write_file' do
+      expect(self).to respond_to(:write_file).with(2).arguments
+    end
+
+    context 'without setting owner' do
+      it 'call upload file with the correct params' do
+        stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        result = instance_double('result')
+        allow(result).to receive(:first).and_return({ 'status' => 'success' })
+        expect(self).to receive(:upload_file).with(local_path, destination, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result)
+        result = write_file(content, destination)
+        expect(result).to be true
+      end
+    end
+
+    context 'when upload encounters an error' do
+      it 'call upload file with the correct params' do
+        stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        result = instance_double('result')
+        allow(result).to receive(:first).and_return({ 'status' => 'failure', 'value' => 'foo error' })
+        expect(self).to receive(:upload_file).with(local_path, destination, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result)
+        expect { write_file(content, destination) }.to raise_error 'foo error'
+      end
+    end
+  end
 end

data/spec/lib/puppet_litmus/rake_helper_spec.rb

@@ -77,6 +77,42 @@ RSpec.describe PuppetLitmus::RakeHelper do
     end
   end
 
+  context 'with bulk tear_down' do
+    let(:inventory_hash) do
+      { 'groups' =>
+        [{ 'name' => 'ssh_nodes', 'targets' =>
+          [
+            { 'uri' => 'one.host', 'facts' => { 'provisioner' => 'abs', 'platform' => 'ubuntu-1604-x86_64', 'job_id' => 'iac-task-pid-21648' } },
+            { 'uri' => 'two.host', 'facts' => { 'provisioner' => 'abs', 'platform' => 'ubuntu-1804-x86_64', 'job_id' => 'iac-task-pid-21648' } },
+            { 'uri' => 'three.host', 'facts' => { 'provisioner' => 'abs', 'platform' => 'ubuntu-2004-x86_64', 'job_id' => 'iac-task-pid-21648' } },
+            { 'uri' => 'four.host', 'facts' => { 'provisioner' => 'abs', 'platform' => 'ubuntu-2004-x86_64', 'job_id' => 'iac-task-pid-21649' } },
+          ] }] }
+    end
+    let(:targets) { ['one.host'] }
+    let(:params) { { 'action' => 'tear_down', 'node_name' => 'one.host', 'inventory' => Dir.pwd } }
+
+    it 'calls function' do
+      allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
+      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('provision::abs', 'localhost', params, config: described_class::DEFAULT_CONFIG_DATA, inventory: nil).and_return(
+        [{ 'target' => 'localhost',
+           'action' => 'task',
+           'object' => 'provision::abs',
+           'status' => 'success',
+           'value' =>
+           { 'status' => 'ok',
+             'removed' =>
+             ['one.host',
+              'two.host',
+              'three.host'] } }],
+      )
+      results = tear_down_nodes(targets, inventory_hash)
+      expect(results.keys).to eq(['one.host', 'two.host', 'three.host'])
+      results.each_value do |value|
+        expect(value[0]['value']).to eq({ 'status' => 'ok' })
+      end
+    end
+  end
+
   context 'with install_agent' do
     let(:inventory_hash) do
       { 'groups' =>

data/spec/lib/puppet_litmus/rake_tasks_spec.rb

@@ -19,9 +19,9 @@ describe 'litmus rake tasks' do
                    'template-ref' => 'heads/master-0-g7827fc2' }
       expect(File).to receive(:read).with(any_args).once
       expect(JSON).to receive(:parse).with(any_args).and_return(metadata)
-      expect(STDOUT).to receive(:puts).with('redhat-5-x86_64')
-      expect(STDOUT).to receive(:puts).with('ubuntu-1404-x86_64')
-      expect(STDOUT).to receive(:puts).with('ubuntu-1804-x86_64')
+      expect($stdout).to receive(:puts).with('redhat-5-x86_64')
+      expect($stdout).to receive(:puts).with('ubuntu-1404-x86_64')
+      expect($stdout).to receive(:puts).with('ubuntu-1804-x86_64')
       Rake::Task['litmus:metadata'].invoke
     end
   end
@@ -39,11 +39,11 @@ describe 'litmus rake tasks' do
       expect_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
       expect(File).to receive(:directory?).with(target_dir).and_return(true)
       expect_any_instance_of(Object).to receive(:build_modules_in_dir).with(target_dir).and_return([dummy_tar])
-      expect(STDOUT).to receive(:puts).with(start_with('Building all modules in'))
+      expect($stdout).to receive(:puts).with(start_with('Building all modules in'))
       expect_any_instance_of(Object).to receive(:upload_file).once.and_return([])
-      expect(STDOUT).to receive(:puts).with(start_with('Installing \'spec/data/doot.tar.gz\''))
+      expect($stdout).to receive(:puts).with(start_with('Installing \'spec/data/doot.tar.gz\''))
       expect_any_instance_of(Object).to receive(:run_command).twice.and_return([])
-      expect(STDOUT).to receive(:puts).with(start_with('Installed \'spec/data/doot.tar.gz\''))
+      expect($stdout).to receive(:puts).with(start_with('Installed \'spec/data/doot.tar.gz\''))
       Rake::Task['litmus:install_modules_from_directory'].invoke('./spec/fixtures/modules')
     end
   end
@@ -68,7 +68,13 @@ describe 'litmus rake tasks' do
 
       allow(File).to receive(:directory?).with(any_args).and_return(true)
       allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with(any_args).and_return(results)
-      expect(STDOUT).to receive(:puts).with('localhost:2222, centos:7')
+      allow_any_instance_of(PuppetLitmus::InventoryManipulation).to receive(:inventory_hash_from_inventory_file).with(any_args).and_return({})
+      allow_any_instance_of(PuppetLitmus::RakeHelper).to receive(:check_connectivity?).with(any_args).and_return(true)
+
+      expect($stdout).to receive(:puts).with('Provisioning centos:7 using docker provisioner.')
+      expect($stdout).to receive(:puts).with("Successfully provisioned centos:7 using docker\n")
+      expect($stdout).to receive(:puts).with('localhost:2222, centos:7')
+
       Rake::Task['litmus:provision'].invoke('docker', 'centos:7')
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet_litmus
 version: !ruby/object:Gem::Version
-  version: 0.18.4
+  version: 0.23.0
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2020-07-01 00:00:00.000000000 Z
+date: 2021-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bolt
@@ -79,7 +79,7 @@ dependencies:
         version: '1.34'
     - - "<"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -89,7 +89,21 @@ dependencies:
         version: '1.34'
     - - "<"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -150,12 +164,14 @@ description: "    Providing a simple command line tool for puppet content creato
   to enable simple and complex test deployments.\n"
 email:
 - info@puppet.com
-executables: []
+executables:
+- matrix_from_metadata
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- exe/matrix_from_metadata
 - lib/puppet_litmus.rb
 - lib/puppet_litmus/inventory_manipulation.rb
 - lib/puppet_litmus/puppet_helpers.rb
@@ -169,10 +185,10 @@ files:
 - spec/data/jim.yaml
 - spec/lib/puppet_litmus/inventory_manipulation_spec.rb
 - spec/lib/puppet_litmus/puppet_helpers_spec.rb
+- spec/lib/puppet_litmus/puppet_litmus_version_spec.rb
 - spec/lib/puppet_litmus/rake_helper_spec.rb
 - spec/lib/puppet_litmus/rake_tasks_spec.rb
 - spec/lib/puppet_litmus/util_spec.rb
-- spec/lib/puppet_litmus/version_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/puppetlabs/puppet_litmus
 licenses:
@@ -186,14 +202,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: Providing a simple command line tool for puppet content creators, to enable
@@ -201,7 +217,7 @@ summary: Providing a simple command line tool for puppet content creators, to en
 test_files:
 - spec/spec_helper.rb
 - spec/lib/puppet_litmus/rake_tasks_spec.rb
-- spec/lib/puppet_litmus/version_spec.rb
+- spec/lib/puppet_litmus/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