puppet_litmus 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc193f9e3e7b23027e022082d77a4349e4db737fc36638d0ca8d9dca433d776d
-  data.tar.gz: 57e68de10c7c77f2b7059163e6ebd1b66852f058e203d3ce7a2d9656f1eb7bd7
+  metadata.gz: 2b4b8f9d03595ac86920511bc3ec0429c34e99ebb54fce2e0dd80bce3d233145
+  data.tar.gz: c4a3bd340f4e215faa647111b6ba933d5669a43e4c06474ab4bc41766fb36235
 SHA512:
-  metadata.gz: f1b37b780a30f7cfca61513debb0d3931ee68524e72f25e4c2c963feeee4012ab56fc4dc7e32717f20de39d15cbefd076198f48659f227bd5bc98134280142cd
-  data.tar.gz: 6b910d580dbc673723f5cb2a0bcaca27f5b88462ffabf5190590c9d0dac3ac5efa18735dada0ea8831a59bf52121763a787e31da4d63af6bc9f4dcd1885302aa
+  metadata.gz: 848d4c8ea4ff3b7b6e02f1404cbbd255d847a259fab02db44032b3982127c5c9a0358366557454f03a85645eb4e9a2ef35bc0e0da90d5fae2d68fb2094912b5d
+  data.tar.gz: 85195c4df6ad10c37290acaba4d14cd4cb2d31950e8095a7afc5104e1a9d3050912dd4ff4a28b6bdcc90b3ff9cc7a956e5b0e1342bad4715ced75542ea0836c4

data/lib/puppet_litmus/inventory_manipulation.rb

@@ -18,6 +18,25 @@ module PuppetLitmus::InventoryManipulation
     inventory_hash
   end
 
+  # Provide a default hash for executing against localhost
+  #
+  # @return [Hash] inventory.yaml hash containing only an entry for localhost
+  def localhost_inventory_hash
+    {
+      'groups' => [
+        {
+          'name' => 'local',
+          'nodes' => [
+            {
+              'name' => 'litmus_localhost',
+              'config' => { 'transport' => 'local' },
+            },
+          ],
+        },
+      ],
+    }
+  end
+
   # Finds targets to perform operations on from an inventory hash.
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file
@@ -51,6 +70,15 @@ module PuppetLitmus::InventoryManipulation
     exists
   end
 
+  # Determines if a node_name exists in the inventory_hash.
+  #
+  # @param inventory_hash [Hash] hash of the inventory.yaml file
+  # @param node_name [String] node to locate in the group
+  # @return [Boolean] true if node_name exists in the inventory_hash.
+  def target_in_inventory?(inventory_hash, node_name)
+    find_targets(inventory_hash, nil).include?(node_name)
+  end
+
   # Finds a config hash in the inventory hash by searching for a node name.
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file
@@ -83,6 +111,22 @@ module PuppetLitmus::InventoryManipulation
     raise "No facts were found for #{node_name}"
   end
 
+  # Finds a var hash in the inventory hash by searching for a node name.
+  #
+  # @param inventory_hash [Hash] hash of the inventory.yaml file
+  # @param node_name [String] node to locate in the group
+  # @return [Hash] vars for node of name node_name
+  def vars_from_node(inventory_hash, node_name)
+    inventory_hash['groups'].each do |group|
+      group['nodes'].each do |node|
+        if node['name'] == node_name
+          return node['vars']
+        end
+      end
+    end
+    {}
+  end
+
   # Adds a node to a group specified, if group_name exists in inventory hash.
   #
   # @param inventory_hash [Hash] hash of the inventory.yaml file

data/lib/puppet_litmus/rake_tasks.rb

@@ -74,32 +74,6 @@ namespace :litmus do
     end
   end
 
-  # DEPRECATED - Provisions all supported OSes with provisioner eg 'bundle exec rake litmus:provision_from_metadata['vmpooler']'.
-  #
-  # @param :provisioner [String] provisioner to use in provisioning all OSes.
-  desc "DEPRECATED: provision_from_metadata task is deprecated.
-  Provision all supported OSes with provisioner eg 'bundle exec rake 'litmus:provision_from_metadata'"
-  task :provision_from_metadata, [:provisioner] do |_task, args|
-    metadata = JSON.parse(File.read('metadata.json'))
-    get_metadata_operating_systems(metadata) do |os_and_version|
-      puts os_and_version
-      include BoltSpec::Run
-      Rake::Task['spec_prep'].invoke
-      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'))
-
-      params = { 'action' => 'provision', 'platform' => os_and_version, 'inventory' => Dir.pwd }
-      results = run_task("provision::#{args[:provisioner]}", 'localhost', params, config: config_data, inventory: nil)
-      results.each do |result|
-        if result['status'] != 'success'
-          puts "Failed on #{result['node']}\n#{result}"
-        else
-          puts "Provisioned #{result['result']['node_name']}"
-        end
-      end
-    end
-  end
-
   # Provisions a list of OSes from provision.yaml file e.g. 'bundle exec rake litmus:provision_list[default]'.
   #
   # @param :key [String] key that maps to a value for a provisioner and an image to be used for each OS provisioned.
@@ -107,6 +81,7 @@ namespace :litmus do
   task :provision_list, [:key] do |_task, args|
     provision_hash = YAML.load_file('./provision.yaml')
     provisioner = provision_hash[args[:key]]['provisioner']
+    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 { |key, value| ENV[key.upcase] = value.to_s }
     failed_image_message = ''
@@ -114,7 +89,7 @@ namespace :litmus do
       # this is the only way to capture the stdout from the rake task, it will affect pry
       capture_rake_output = StringIO.new
       $stdout = capture_rake_output
-      Rake::Task['litmus:provision'].invoke(provisioner, image)
+      Rake::Task['litmus:provision'].invoke(provisioner, image, inventory_vars)
       if $stdout.string =~ %r{.status.=>.failure}
         failed_image_message += "=====\n#{image}\n#{$stdout.string}\n"
       else
@@ -130,30 +105,43 @@ namespace :litmus do
   # @param :provisioner [String] provisioner to use in provisioning given platform.
   # @param :platform [String] OS platform for container or VM to use.
   desc "provision container/VM - abs/docker/vagrant/vmpooler eg 'bundle exec rake 'litmus:provision[vmpooler, ubuntu-1604-x86_64]'"
-  task :provision, [:provisioner, :platform] do |_task, args|
+  task :provision, [:provisioner, :platform, :inventory_vars] do |_task, args|
     include BoltSpec::Run
     Rake::Task['spec_prep'].invoke
     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'))
 
     unless %w[abs docker docker_exp vagrant vmpooler].include?(args[:provisioner])
-      raise "Unknown provisioner '#{args[:provisioner]}', try abs/docker/vagrant/vmpooler"
+      raise "Unknown provisioner '#{args[:provisioner]}', try abs/docker/docker_exp/vagrant/vmpooler"
     end
 
-    params = { 'action' => 'provision', 'platform' => args[:platform], 'inventory' => Dir.pwd }
-    spinner = if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
-                TTY::Spinner.new(':spinner', frames: ['.'], interval: 0.1)
-              else
-                TTY::Spinner.new("Provisioning #{args[:platform]} using #{args[:provisioner]} provisioner.[:spinner]")
-              end
-    spinner.auto_spin
+    params = if args[:inventory_vars].nil?
+               { 'action' => 'provision', 'platform' => args[:platform], 'inventory' => Dir.pwd }
+             else
+               { 'action' => 'provision', 'platform' => args[:platform], 'inventory' => Dir.pwd, 'vars' => args[:inventory_vars] }
+             end
+
+    if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
+      progress = Thread.new do
+        loop do
+          printf '.'
+          sleep(10)
+        end
+      end
+    else
+      spinner = TTY::Spinner.new("Provisioning #{args[:platform]} using #{args[:provisioner]} provisioner.[:spinner]")
+      spinner.auto_spin
+    end
     results = run_task("provision::#{args[:provisioner]}", 'localhost', params, config: config_data, inventory: nil)
     if results.first['status'] != 'success'
-      spinner.error
       raise "Failed provisioning #{args[:platform]} using #{args[:provisioner]}\n#{results.first}"
     end
 
-    spinner.success
+    if (ENV['CI'] == 'true') || !ENV['DISTELLI_BUILDNUM'].nil?
+      Thread.kill(progress)
+    else
+      spinner.success
+    end
     puts "#{results.first['result']['node_name']}, #{args[:platform]}"
   end
 
@@ -189,7 +177,10 @@ namespace :litmus do
     end
 
     # fix the path on ssh_nodes
-    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' }.size.zero? # rubocop:disable Metrics/LineLength
+    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)
+    end
     results.each do |result|
       if result['status'] != 'success'
         puts "Failed on #{result['node']}\n#{result}"
@@ -197,58 +188,6 @@ namespace :litmus do
     end
   end
 
-  # Install puppet enterprise - for internal puppet employees only - Requires an el7 provisioned machine - experimental feature [:target_node_name]'
-  #
-  # @param :target_node_name [Array] nodes on which to install puppet agent.
-  desc 'install puppet enterprise - for internal puppet employees only - Requires an el7 provisioned machine - experimental feature [:target_node_name]'
-  task :install_pe, [:target_node_name] do |_task, args|
-    inventory_hash = inventory_hash_from_inventory_file
-    target_nodes = find_targets(inventory_hash, args[:target_node_name])
-    if target_nodes.empty?
-      puts 'No targets found'
-      exit 0
-    end
-    puts 'install_pe'
-    include BoltSpec::Run
-    Rake::Task['spec_prep'].invoke
-    config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
-
-    puts 'Setting up parameters'
-
-    PE_RELEASE = 2019.0
-    pe_latest_cmd = "curl http://enterprise.delivery.puppetlabs.net/#{PE_RELEASE}/ci-ready/LATEST"
-    pe_latest = run_command(pe_latest_cmd, target_nodes, config: config_data, inventory: inventory_hash)
-    pe_latest_string = pe_latest[0]['result']['stdout'].delete("\n")
-    PE_FILE_NAME = "puppet-enterprise-#{pe_latest_string}-el-7-x86_64"
-    TAR_FILE = "#{PE_FILE_NAME}.tar"
-    DOWNLOAD_URL = "http://enterprise.delivery.puppetlabs.net/#{PE_RELEASE}/ci-ready/#{TAR_FILE}"
-
-    puts 'Initiating PE download'
-
-    # Download PE
-    download_pe_cmd = "wget -q #{DOWNLOAD_URL}"
-    run_command(download_pe_cmd, target_nodes, config: config_data, inventory: inventory_hash)
-
-    puts 'PE successfully downloaded, running installer (this may take 5 or so minutes, please be patient)'
-
-    # Install PE
-    untar_cmd = "tar xvf #{TAR_FILE}"
-    run_command(untar_cmd, target_nodes, config: config_data, inventory: inventory_hash)
-    puts run_command("cd #{PE_FILE_NAME} && 1 | ./puppet-enterprise-installer", target_nodes, config: nil, inventory: inventory_hash)[0]['result']['stdout']
-
-    puts 'Autosigning Certificates'
-
-    # Set Autosign
-    autosign_cmd = "echo 'autosign = true' >> /etc/puppetlabs/puppet/puppet.conf"
-    run_command(autosign_cmd, target_nodes, config: config_data, inventory: inventory_hash)
-
-    puts 'Finishing installation with a Puppet Agent run'
-
-    run_command('puppet agent -t', target_nodes, config: config_data, inventory: inventory_hash)
-
-    puts 'PE Installation is now complete'
-  end
-
   # Install the puppet module under test on a collection of nodes
   #
   # @param :target_node_name [Array] nodes on which to install a puppet module for testing.
@@ -283,15 +222,13 @@ namespace :litmus do
     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)}"
     result = run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash)
-    # rubocop:disable Style/GuardClause
-    if result.is_a?(Array)
-      result.each do |node|
-        puts "#{node['node']} failed #{node['result']}" if node['status'] != 'success'
-      end
-    else
-      raise "Failed trying to run '#{install_module_command}' against inventory."
+
+    raise "Failed trying to run '#{install_module_command}' against inventory." unless result.is_a?(Array)
+
+    result.each do |node|
+      puts "#{node['node']} failed #{node['result']}" if node['status'] != 'success'
     end
-    # rubocop:enable Style/GuardClause
+
     puts 'Installed'
   end
 
@@ -325,6 +262,8 @@ namespace :litmus do
 
     bad_results = []
     targets.each do |node_name|
+      next if node_name == 'litmus_localhost'
+
       # how do we know what provisioner to use
       node_facts = facts_from_node(inventory_hash, node_name)
       next unless %w[abs docker docker_exp vagrant vmpooler].include?(node_facts['provisioner'])
@@ -361,7 +300,7 @@ namespace :litmus do
         payloads = []
         # Generate list of targets to provision
         targets.each do |target|
-          test = 'bundle exec bundle exec rspec ./spec/acceptance --format progress'
+          test = 'bundle exec rspec ./spec/acceptance --format progress'
           title = "#{target}, #{facts_from_node(inventory_hash, target)['platform']}"
           options = {
             env: {
@@ -446,6 +385,8 @@ namespace :litmus do
 
       targets.each do |target|
         desc "Run serverspec against #{target}"
+        next if target == 'litmus_localhost'
+
         RSpec::Core::RakeTask.new(target.to_sym) do |t|
           t.pattern = 'spec/acceptance/**{,/*/**}/*_spec.rb'
           ENV['TARGET_HOST'] = target

data/lib/puppet_litmus/serverspec.rb

@@ -9,7 +9,7 @@ module PuppetLitmus::Serverspec
   # @return [Boolean] The result of the 2 apply manifests.
   def idempotent_apply(manifest)
     manifest_file_location = create_manifest_file(manifest)
-    apply_manifest(nil, catch_failures: true, manifest_file_location: manifest_file_location)
+    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
 
@@ -24,8 +24,10 @@ module PuppetLitmus::Serverspec
   #
   # @param manifest [String] puppet manifest code to be applied.
   # @param opts [Hash] Alters the behaviour of the command. Valid options are:  
-  #  :catch_changes [Boolean] exit status of 1 if there were changes.  
-  #  :expect_failures [Boolean] doesnt return an exit code of non-zero if the apply failed.  
+  #  :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'".  
@@ -35,25 +37,47 @@ module PuppetLitmus::Serverspec
   # @return [Object] A result object from the apply.
   def apply_manifest(manifest, opts = {})
     # rubocop:enable Layout/TrailingWhitespace
-    target_node_name = ENV['TARGET_HOST']
+    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
 
     manifest_file_location = opts[:manifest_file_location] || create_manifest_file(manifest)
-    inventory_hash = if target_node_name.nil? || target_node_name == 'localhost'
-                       nil
-                     else
-                       inventory_hash_from_inventory_file
-                     end
+    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.nil? || target_node_name == 'localhost'
+    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 += ' --detailed-exitcodes' if !opts[:catch_changes].nil? && (opts[:catch_changes] == true)
     command_to_run += ' --debug' if !opts[:debug].nil? && (opts[:debug] == true)
     command_to_run += ' --noop' if !opts[:noop].nil? && (opts[:noop] == true)
-    result = run_command(command_to_run, target_node_name, config: nil, inventory: inventory_hash)
+    command_to_run += ' --detailed-exitcodes' if use_detailed_exit_codes == true
 
-    raise "apply manifest failed\n`#{command_to_run}`\n======\n#{result}" if result.first['result']['exit_code'] != 0 && opts[:expect_failures] != 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
 
     result = OpenStruct.new(exit_code: result.first['result']['exit_code'],
                             stdout: result.first['result']['stdout'],
@@ -98,12 +122,10 @@ module PuppetLitmus::Serverspec
   # @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 = {})
-    target_node_name = ENV['TARGET_HOST']
-    inventory_hash = if target_node_name.nil? || target_node_name == 'localhost'
-                       nil
-                     else
-                       inventory_hash_from_inventory_file
-                     end
+    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)
     raise "shell failed\n`#{command_to_run}`\n======\n#{result}" if result.first['result']['exit_code'] != 0 && opts[:expect_failures] != true
 
@@ -122,12 +144,9 @@ module PuppetLitmus::Serverspec
   # @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 = {})
-    target_node_name = ENV['TARGET_HOST'] if target_node_name.nil?
-    inventory_hash = if target_node_name.nil? || target_node_name == 'localhost'
-                       nil
-                     else
-                       inventory_hash_from_inventory_file
-                     end
+    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)
 
@@ -160,12 +179,9 @@ module PuppetLitmus::Serverspec
   # @return [Object] A result object from the task.The values available are stdout, stderr and result.
   def run_bolt_task(task_name, params = {}, opts = {})
     config_data = { 'modulepath' => File.join(Dir.pwd, 'spec', 'fixtures', 'modules') }
-    target_node_name = ENV['TARGET_HOST'] if target_node_name.nil?
-    inventory_hash = if target_node_name.nil? || target_node_name == 'localhost'
-                       nil
-                     else
-                       inventory_hash_from_inventory_file
-                     end
+    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_task(task_name, target_node_name, params, config: config_data, inventory: inventory_hash)
     result_obj = {
@@ -210,12 +226,9 @@ module PuppetLitmus::Serverspec
   # @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: [])
-    target_node_name = ENV['TARGET_HOST'] if target_node_name.nil?
-    inventory_hash = if target_node_name.nil? || target_node_name == 'localhost'
-                       nil
-                     else
-                       inventory_hash_from_inventory_file
-                     end
+    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)
 
@@ -227,4 +240,67 @@ module PuppetLitmus::Serverspec
     yield result if block_given?
     result
   end
+
+  # Determines if the current execution is targeting localhost or not
+  #
+  # @return [Boolean] true if targeting localhost in the tests
+  def targeting_localhost?
+    ENV['TARGET_HOST'].nil? || ENV['TARGET_HOST'] == 'localhost'
+  end
+
+  private
+
+  # 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)
+    puppet_apply_error = <<-ERROR
+apply manifest failed
+`#{command}`
+with exit code #{result.first['result']['exit_code']} (expected: #{acceptable_exit_codes})
+====== Start output of failed Puppet apply ======
+#{puppet_output(result)}
+====== End output of failed Puppet apply ======
+    ERROR
+    raise puppet_apply_error
+  end
+
+  # 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)
+    puppet_apply_changes = <<-ERROR
+apply manifest expected no changes
+`#{command}`
+====== Start output of Puppet apply with unexpected changes ======
+#{puppet_output(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
+  end
+
+  # Checks a puppet return status and returns true if it both
+  # the catalog compiled and the apply was successful. Either
+  # with or without changes
+  #
+  # @param exit_status [Integer] The status of the puppet run.
+  def puppet_successful?(exit_status)
+    [0, 2].include?(exit_status)
+  end
+
+  # Checks a puppet return status and returns true if
+  # puppet reported any changes
+  #
+  # @param exit_status [Integer] The status of the puppet run.
+  def puppet_changes?(exit_status)
+    [2, 6].include?(exit_status)
+  end
 end

data/lib/puppet_litmus/version.rb

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

data/spec/lib/puppet_litmus/inventory_manipulation_spec.rb

@@ -25,7 +25,8 @@ RSpec.describe PuppetLitmus::InventoryManipulation do
      'nodes' =>
      [{ 'name' => 'test.delivery.puppetlabs.net',
         'config' => { 'transport' => 'ssh', 'ssh' => { 'user' => 'root', 'password' => 'Qu@lity!', 'host-key-check' => false } },
-        'facts' => { 'provisioner' => 'vmpooler', 'platform' => 'centos-5-x86_64' } }] },
+        'facts' => { 'provisioner' => 'vmpooler', 'platform' => 'centos-5-x86_64' },
+        'vars' => { 'role' => 'agent' } }] },
    { 'name' => 'winrm_nodes', 'nodes' => [] }] }
     end
 
@@ -98,6 +99,14 @@ RSpec.describe PuppetLitmus::InventoryManipulation do
 { 'user' => 'root', 'password' => 'Qu@lity!', 'host-key-check' => false })
     end
 
+    it 'facts exists, and returns' do
+      expect(dummy_class.facts_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('provisioner' => 'vmpooler', 'platform' => 'centos-5-x86_64')
+    end
+
+    it 'vars exists, and returns' do
+      expect(dummy_class.vars_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('role' => 'agent')
+    end
+
     it 'no feature exists for the group, and returns hash with feature added' do
       expect(dummy_class.add_feature_to_group(no_feature_hash, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'nodes' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'name' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'nodes' => [] }]) # rubocop:disable Metrics/LineLength: Line is too long
     end

data/spec/lib/puppet_litmus/serverspec_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe PuppetLitmus::Serverspec do
 
     it 'calls all functions' do
       expect(dummy_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-      expect(dummy_class).to receive(:apply_manifest).with(nil, catch_failures: true, manifest_file_location: '/bla.pp')
+      expect(dummy_class).to receive(:apply_manifest).with(nil, expect_failures: false, manifest_file_location: '/bla.pp')
       expect(dummy_class).to receive(:apply_manifest).with(nil, catch_changes: true, manifest_file_location: '/bla.pp')
       dummy_class.idempotent_apply(manifest)
     end
@@ -25,21 +25,74 @@ RSpec.describe PuppetLitmus::Serverspec 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'" }
 
       it 'passes the --hiera_config flag if the :hiera_config opt is specified' do
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(dummy_class).to receive(:run_command).with(command, nil, config: nil, inventory: nil).and_return(result)
+        expect(dummy_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         dummy_class.apply_manifest(manifest, hiera_config: '/hiera.yaml')
       end
     end
+
+    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" }
+
+      it 'uses detailed-exitcodes with expect_failures' do
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(dummy_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { dummy_class.apply_manifest(manifest, expect_failures: true) }.to raise_error(RuntimeError)
+      end
+
+      it 'uses detailed-exitcodes with catch_failures' do
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(dummy_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        dummy_class.apply_manifest(manifest, catch_failures: true)
+      end
+
+      it 'uses detailed-exitcodes with expect_changes' do
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(dummy_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { dummy_class.apply_manifest(manifest, expect_changes: true) }.to raise_error(RuntimeError)
+      end
+
+      it 'uses detailed-exitcodes with catch_changes' do
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(dummy_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        dummy_class.apply_manifest(manifest, catch_changes: true)
+      end
+
+      it 'uses raises exception for multiple options' do
+        expect { dummy_class.apply_manifest(manifest, catch_changes: true, expect_failures: true) }
+          .to raise_error(RuntimeError, 'please specify only one of `catch_changes`, `expect_changes`, `catch_failures` or `expect_failures`')
+      end
+    end
   end
 
   describe '.run_shell' do
     let(:command_to_run) { "puts 'doot'" }
     let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
-    let(:inventory_hash) { Hash.new(0) }
+    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(dummy_class).to respond_to(:run_shell).with(1..2).arguments
@@ -48,7 +101,10 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when running against localhost and no inventory.yaml file' do
       it 'does run_shell against localhost without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
-        expect(dummy_class).to receive(:run_command).with(command_to_run, 'localhost', config: nil, inventory: nil).and_return(result)
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:run_command).with(command_to_run, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { dummy_class.run_shell(command_to_run) }.not_to raise_error
       end
     end
@@ -56,7 +112,9 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when running against remote host' do
       it 'does run_shell 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(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_command).with(command_to_run, 'some.host', config: nil, inventory: inventory_hash).and_return(result)
         expect { dummy_class.run_shell(command_to_run) }.not_to raise_error
       end
@@ -71,7 +129,8 @@ RSpec.describe PuppetLitmus::Serverspec 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 SpaceInsideHashLiteralBraces, SpaceInsideBlockBraces, SpaceAroundOperators, LineLength, SpaceAfterComma
-    let(:inventory_hash) { Hash.new(0) }
+    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(dummy_class).to respond_to(:bolt_upload_file).with(2..3).arguments
@@ -80,14 +139,19 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when upload returns success' do
       it 'does upload_file 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(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_success)
         expect { dummy_class.bolt_upload_file(local, remote) }.not_to raise_error
       end
       it 'does upload_file against localhost without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
         expect(dummy_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(dummy_class).to receive(:upload_file).with(local, remote, 'localhost', options: {}, config: nil, inventory: nil).and_return(result_success)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:upload_file).with(local, remote, 'litmus_localhost', options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result_success)
         expect { dummy_class.bolt_upload_file(local, remote) }.not_to raise_error
       end
     end
@@ -95,13 +159,17 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when upload returns failure' do
       it 'does upload_file gives runtime error for failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
         expect { dummy_class.bolt_upload_file(local, remote) }.to raise_error(RuntimeError, %r{upload file failed})
       end
       it 'returns the exit code and error message when expecting failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
         method_result = dummy_class.bolt_upload_file(local, remote, expect_failures: true)
         expect(method_result.exit_code).to be(255)
@@ -113,7 +181,8 @@ RSpec.describe PuppetLitmus::Serverspec do
   describe '.bolt_run_script' do
     let(:script) { '/tmp/script.sh' }
     let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
-    let(:inventory_hash) { Hash.new(0) }
+    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(dummy_class).to respond_to(:bolt_run_script).with(1..2).arguments
@@ -122,8 +191,11 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when running against localhost and no inventory.yaml file' do
       it 'does bolt_run_script against localhost without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
         expect(dummy_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(dummy_class).to receive(:run_script).with(script, 'localhost', [], options: {}, config: nil, inventory: nil).and_return(result)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:run_script).with(script, 'litmus_localhost', [], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { dummy_class.bolt_run_script(script) }.not_to raise_error
       end
     end
@@ -131,7 +203,9 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when running against remote host' 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(dummy_class).to receive(:inventory_hash_from_inventory_file)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: nil).and_return(result)
         expect { dummy_class.bolt_run_script(script) }.not_to raise_error
       end
@@ -140,8 +214,11 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when running with arguments' do
       it 'does bolt_run_script with arguments without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'localhost'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(false)
+        expect(dummy_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
         expect(dummy_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(dummy_class).to receive(:run_script).with(script, 'localhost', ['doot'], options: {}, config: nil, inventory: nil).and_return(result)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
+        expect(dummy_class).to receive(:run_script).with(script, 'litmus_localhost', ['doot'], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
         expect { dummy_class.bolt_run_script(script, arguments: ['doot']) }.not_to raise_error
       end
     end
@@ -157,7 +234,7 @@ RSpec.describe PuppetLitmus::Serverspec 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 SpaceInsideHashLiteralBraces, SpaceBeforeBlockBraces, SpaceInsideBlockBraces, SpaceAroundOperators, LineLength, SpaceAfterComma
-    let(:inventory_hash) { Hash.new(0) }
+    let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'some.host', 'config' => { 'transport' => 'local' } }] }] } }
 
     it 'responds to bolt_run_task' do
       expect(dummy_class).to respond_to(:run_bolt_task).with(2..3).arguments
@@ -166,20 +243,26 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when bolt returns success' do
       it 'does bolt_task_run gives no runtime error for success' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
         expect { dummy_class.run_bolt_task(task_name, params, opts: {}) }.not_to raise_error
       end
       it 'returns stdout for unstructured-data tasks' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
         method_result = dummy_class.run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('SUCCESS!')
       end
       it 'returns structured output for structured-data tasks' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_structured_task_success)
         method_result = dummy_class.run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('{"key1"=>"foo", "key2"=>"bar"}')
@@ -191,13 +274,17 @@ RSpec.describe PuppetLitmus::Serverspec do
     context 'when bolt returns failure' do
       it 'does bolt_task_run gives runtime error for failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
         expect { dummy_class.run_bolt_task(task_name, params, opts: {}) }.to raise_error(RuntimeError, %r{task failed})
       end
       it 'returns the exit code and error message when expecting failure' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
+        expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
         expect(dummy_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(dummy_class).to receive(:target_in_inventory?).and_return(true)
         expect(dummy_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
         method_result = dummy_class.run_bolt_task(task_name, params, expect_failures: true)
         expect(method_result.exit_code).to be(123)

data/spec/spec_helper.rb

@@ -6,9 +6,14 @@ require 'puppet_litmus'
 if ENV['COVERAGE'] == 'yes'
   require 'simplecov'
 
-  SimpleCov.formatters = [
-    SimpleCov::Formatter::HTMLFormatter,
-  ]
+  if ENV['CI'] == 'true'
+    require 'codecov'
+    SimpleCov.formatter = SimpleCov::Formatter::Codecov
+  else
+    SimpleCov.formatters = [
+      SimpleCov::Formatter::HTMLFormatter,
+    ]
+  end
   SimpleCov.start do
     track_files 'lib/**/*.rb'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet_litmus
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-30 00:00:00.000000000 Z
+date: 2019-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bolt
@@ -111,15 +111,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.10
 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/data/inventory.yaml
-- spec/lib/puppet_litmus/serverspec_spec.rb
-- spec/lib/puppet_litmus/inventory_manipulation_spec.rb
+- spec/spec_helper.rb
 - spec/lib/puppet_litmus/rake_tasks_spec.rb
 - spec/lib/puppet_litmus/version_spec.rb
-- spec/spec_helper.rb
+- spec/lib/puppet_litmus/inventory_manipulation_spec.rb
+- spec/lib/puppet_litmus/serverspec_spec.rb
+- spec/data/inventory.yaml