puppet_litmus 0.17.0 → 0.18.4

data/lib/puppet_litmus/rake_tasks.rb

@@ -17,15 +17,15 @@ namespace :litmus do
   end
 
   # Provisions a list of OSes from provision.yaml file e.g. 'bundle exec rake litmus:provision_list[default]'.
-  # @See https://github.com/puppetlabs/puppet_litmus/wiki/Overview-of-Litmus#provisioning-via-yaml
+  # @See https://puppetlabs.github.io/litmus/Litmus-core-commands.html#provisioning-via-yaml
   #
   # @param :key [String] key that maps to a value for a provisioner and an image to be used for each OS provisioned.
-  desc "provision list of machines from provision.yaml file. 'bundle exec rake 'litmus:provision_list[default]'"
+  desc 'provision list of machines from provision.yaml file'
   task :provision_list, [:key] do |_task, args|
     raise 'Cannot find provision.yaml file' unless File.file?('./provision.yaml')
 
     provision_hash = YAML.load_file('./provision.yaml')
-    raise "No key #{args[:key]} in ./provision.yaml, see https://github.com/puppetlabs/puppet_litmus/wiki/Overview-of-Litmus#provisioning-via-yaml for examples" if provision_hash[args[:key]].nil?
+    raise "No key #{args[:key]} in ./provision.yaml, see https://puppetlabs.github.io/litmus/Litmus-core-commands.html#provisioning-via-yaml for examples" if provision_hash[args[:key]].nil?
 
     Rake::Task['spec_prep'].invoke
 
@@ -57,9 +57,9 @@ namespace :litmus do
       end
 
       if result.first['status'] != 'success'
-        failed_image_message += "=====\n#{result.first['node']}\n#{result.first['result']['_output']}\n#{result.inspect}"
+        failed_image_message += "=====\n#{result.first['target']}\n#{result.first['value']['_output']}\n#{result.inspect}"
       else
-        STDOUT.puts "#{result.first['result']['node_name']}, #{image}"
+        STDOUT.puts "#{result.first['value']['node_name']}, #{image}"
       end
       results << result
     end
@@ -71,7 +71,7 @@ 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]'"
+  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?
@@ -96,14 +96,14 @@ namespace :litmus do
     else
       spinner.success
     end
-    puts "#{results.first['result']['node_name']}, #{args[:platform]}"
+    puts "#{results.first['value']['node_name']}, #{args[:platform]}"
   end
 
   # Install puppet agent on a collection of nodes
   #
   # @param :collection [String] parameters to pass to the puppet agent install command.
   # @param :target_node_name [Array] nodes on which to install puppet agent.
-  desc 'install puppet agent, [:collection, :target_node_name]'
+  desc 'install a puppet agent to all or a specified set of targets'
   task :install_agent, [:collection, :target_node_name] do |_task, args|
     inventory_hash = inventory_hash_from_inventory_file
     targets = find_targets(inventory_hash, args[:target_node_name])
@@ -119,11 +119,11 @@ 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['node']} --inventoryfile inventory.yaml --modulepath #{DEFAULT_CONFIG_DATA['modulepath']}"
-        raise "Failed on #{result['node']}\n#{result}\ntry running '#{command_to_run}'"
+        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['node'])
+        inventory_hash = add_feature_to_node(inventory_hash, 'puppet-agent', result['target'])
       end
     end
     # update the inventory with the puppet-agent feature set per node
@@ -134,7 +134,7 @@ namespace :litmus do
 
     results.each do |result|
       if result['status'] != 'success'
-        puts "Failed on #{result['node']}\n#{result}"
+        puts "Failed on #{result['target']}\n#{result}"
       end
     end
   end
@@ -143,7 +143,7 @@ namespace :litmus do
   #
   # @param :target_node_name [Array] nodes on which to add the feature.
   # @param :added_feature [String] the feature which you wish to add.
-  desc 'add_feature, [:added_feature, :target_node_name]'
+  desc 'add a feature tag to a node'
   task :add_feature, [:added_feature, :target_node_name] do |_task, args|
     inventory_hash = inventory_hash_from_inventory_file
     targets = find_targets(inventory_hash, args[:target_node_name])
@@ -166,65 +166,69 @@ namespace :litmus do
     puts 'Feature added'
   end
 
-  # Install the puppet modules from a source directory to nodes. It does not install dependencies.
+  # Install the puppet module under test on a collection of nodes
   #
-  # @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 'install_module - build and install module'
-  task :install_modules_from_directory, [:source, :target_node_name] do |_task, args|
+  desc 'build the module under test and install it onto targets'
+  task :install_module, [:target_node_name, :module_repository] do |_task, args|
+    args.with_defaults(target_node_name: nil, module_repository: nil)
     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
-    source_folder = if args[:source].nil?
-                      './spec/fixtures/modules'
-                    else
-                      File.expand_path(args[:source])
-                    end
-    raise "Source folder doesnt exist #{source_folder}" unless File.directory?(source_folder)
-
-    module_tars = build_modules_in_folder(source_folder)
-    puts 'Building'
-    module_tars.each do |module_tar|
-      print "#{File.basename(module_tar)} "
-    end
-    require 'bolt_spec/run'
-    include BoltSpec::Run
-    puts "\nSending"
-    module_tars.each do |module_tar|
-      upload_file(module_tar.path, "/tmp/#{File.basename(module_tar)}", target_nodes, options: {}, config: nil, inventory: inventory_hash)
-      print "#{File.basename(module_tar)} "
-    end
-    puts "\nInstalling"
-    module_tars.each do |module_tar|
-      # install_module
-      install_module_command = "puppet module install --force /tmp/#{File.basename(module_tar)}"
-      run_command(install_module_command, target_nodes, config: nil, inventory: inventory_hash)
-      print "#{File.basename(module_tar)} "
-    end
+
+    module_tar = build_module
+    puts "Built '#{module_tar}'"
+
+    # module_tar = Dir.glob('pkg/*.tar.gz').max_by { |f| File.mtime(f) }
+    raise "Unable to find package in 'pkg/*.tar.gz'" if module_tar.nil?
+
+    install_module(inventory_hash, args[:target_node_name], module_tar, args[:module_repository])
+
+    puts "Installed '#{module_tar}' on #{args[:target_node_name]}"
   end
 
-  # Check that the nodes in the inventory are still contactable
+  # Install the puppet modules from a source directory to nodes. It does not install dependencies.
   #
-  # @param :target_node_name [Array] nodes on which to check connnectivity
-  desc 'check_connectivity - build and install module'
-  task :check_connectivity, [:target_node_name] do |_task, args|
+  # @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)
     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
-    check_connectivity?(inventory_hash, args[:target_node_name])
+    source_dir = if args[:source].nil?
+                   './spec/fixtures/modules'
+                 else
+                   File.expand_path(args[:source])
+                 end
+    raise "Source directory doesn't exist #{source_dir}" unless File.directory?(source_dir)
+
+    puts "Building all modules in #{source_dir.inspect}"
+    module_tars = build_modules_in_dir(source_dir)
+    require 'bolt_spec/run'
+    include BoltSpec::Run
+    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])
+        puts "Installed '#{module_tar}' on #{target_node_name}"
+      end
+    end
   end
 
-  # Install the puppet module under test on a collection of nodes
+  # Uninstall 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.
-  desc 'install_module - build and install module'
-  task :install_module, [:target_node_name] do |_task, args|
+  # @param :module_name [String] module name to be uninstalled
+  desc 'uninstall a specific module'
+  task :uninstall_module, [:target_node_name, :module_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?
@@ -232,39 +236,58 @@ namespace :litmus do
       exit 0
     end
 
-    module_tar = build_module
-    puts 'Built'
-
-    # module_tar = Dir.glob('pkg/*.tar.gz').max_by { |f| File.mtime(f) }
-    raise "Unable to find package in 'pkg/*.tar.gz'" if module_tar.nil?
-
-    result = install_module(inventory_hash, args[:target_node_name], module_tar)
+    result = uninstall_module(inventory_hash, args[:target_node_name], args[:module_name])
 
-    raise "Failed trying to run 'puppet module install /tmp/#{File.basename(module_tar)}' against inventory." unless result.is_a?(Array)
+    raise "Failed trying to run 'puppet module uninstall #{module_name}' against inventory." unless result.is_a?(Array)
 
     result.each do |node|
-      puts "#{node['node']} failed #{node['result']}" if node['status'] != 'success'
+      puts "#{node['target']} failed #{node['value']}" if node['status'] != 'success'
     end
 
-    puts 'Installed'
+    puts 'Uninstalled'
+  end
+
+  # Reinstall 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.
+  desc 'reinstall the module under test'
+  task :reinstall_module, [:target_node_name, :module_repository] do |_task, args|
+    args.with_defaults(target_node_name: nil, module_repository: nil)
+    Rake::Task['litmus:uninstall_module'].invoke(args[:target_node_name])
+    Rake::Task['litmus:install_module'].invoke(args[:target_node_name], args[:module_repository])
+  end
+
+  # Check that the nodes in the inventory are still contactable
+  #
+  # @param :target_node_name [Array] nodes on which to check connnectivity
+  desc 'check the connectivity to all provisioned targets'
+  task :check_connectivity, [: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
+    check_connectivity?(inventory_hash, args[:target_node_name])
   end
 
   # Provision a list of machines, install a puppet agent, and install the puppet module under test on a collection of nodes
   #
   # @param :key [String] key that maps to a value for a provisioner and an image to be used for each OS provisioned.
   # @param :collection [String] parameters to pass to the puppet agent install command.
-  desc 'provision_install - provision a list of machines, install an agent, and the module.'
-  task :provision_install, [:key, :collection] do |_task, args|
+  desc 'provision a list of machines, install an agent, and the module.'
+  task :provision_install, [:key, :collection, :module_repository] do |_task, args|
+    args.with_defaults(module_repository: nil)
     Rake::Task['spec_prep'].invoke
     Rake::Task['litmus:provision_list'].invoke(args[:key])
     Rake::Task['litmus:install_agent'].invoke(args[:collection])
-    Rake::Task['litmus:install_module'].invoke
+    Rake::Task['litmus:install_module'].invoke(nil, args[:module_repository])
   end
 
   # Decommissions test machines.
   #
   # @param :target [Array] nodes to remove from test environemnt and decommission.
-  desc 'tear-down - decommission machines'
+  desc 'destroy provisioned targets'
   task :tear_down, [:target] do |_task, args|
     inventory_hash = inventory_hash_from_inventory_file
     targets = find_targets(inventory_hash, args[:target])
@@ -277,7 +300,7 @@ namespace :litmus do
     results = tear_down_nodes(targets, inventory_hash)
     results.each do |node, result|
       if result.first['status'] != 'success'
-        bad_results << "#{node}, #{result.first['result']['_error']['msg']}"
+        bad_results << "#{node}, #{result.first['value']['_error']['msg']}"
       else
         puts "#{node}: #{result.first['status']}"
       end
@@ -290,39 +313,6 @@ namespace :litmus do
     end
   end
 
-  # Uninstall 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.
-  # @param :module_name [String] module name to be uninstalled
-  desc 'uninstall_module - uninstall module'
-  task :uninstall_module, [:target_node_name, :module_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
-
-    result = uninstall_module(inventory_hash, args[:target_node_name], args[:module_name])
-
-    raise "Failed trying to run 'puppet module uninstall #{module_name}' against inventory." unless result.is_a?(Array)
-
-    result.each do |node|
-      puts "#{node['node']} failed #{node['result']}" if node['status'] != 'success'
-    end
-
-    puts 'Uninstalled'
-  end
-
-  # Reinstall 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.
-  desc 'reinstall_module - reinstall module'
-  task :reinstall_module, [:target_node_name] do |_task, args|
-    Rake::Task['litmus:uninstall_module'].invoke(args[:target_node_name])
-    Rake::Task['litmus:install_module'].invoke(args[:target_node_name])
-  end
-
   namespace :acceptance do
     require 'rspec/core/rake_task'
     if File.file?('inventory.yaml')
@@ -365,8 +355,12 @@ namespace :litmus do
 
           require 'parallel'
           results = Parallel.map(payloads) do |title, test, options|
+            # avoid sending the parent process' main span in the sub-processes
+            # https://www.ruby-forum.com/t/at-exit-inherited-across-fork/122473/2
+            at_exit { exit! }
+
             env = options[:env].nil? ? {} : options[:env]
-            ENV['HTTP_X_HONEYCOMB_TRACE'] = Honecomb.current_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
+            env['HTTP_X_HONEYCOMB_TRACE'] = Honeycomb.current_span.to_trace_header
             stdout, stderr, status = Open3.capture3(env, test)
             ["\n================\n#{title}\n", stdout, stderr, status]
           end
@@ -384,8 +378,8 @@ 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
             spinners.register("[:spinner] #{title}") do |sp|
-              ENV['HTTP_X_HONEYCOMB_TRACE'] = Honecomb.current_span.to_trace_header unless ENV['HTTP_X_HONEYCOMB_TRACE']
               stdout, stderr, status = Open3.capture3(env, test)
               if status.to_i.zero?
                 sp.success

data/lib/puppet_litmus/spec_helper_acceptance.rb

@@ -66,7 +66,7 @@ module PuppetLitmus
                end
         set :host,        options[:host_name] || host
         set :ssh_options, options
-        set :request_pty, true
+        set :request_pty, false
       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.17.0'
+  VERSION ||= '0.18.4'
 end

data/spec/lib/puppet_litmus/inventory_manipulation_spec.rb

@@ -92,70 +92,70 @@ RSpec.describe PuppetLitmus::InventoryManipulation do
     end
 
     it 'no matching node, raises' do
-      expect { described_class.config_from_node(config_hash, 'not.here') }.to raise_error('No config was found for not.here')
+      expect { config_from_node(config_hash, 'not.here') }.to raise_error('No config was found for not.here')
     end
 
     it 'no config section, returns nil' do
-      expect(described_class.config_from_node(no_config_hash, 'test.delivery.puppetlabs.net')).to eq(nil)
+      expect(config_from_node(no_config_hash, 'test.delivery.puppetlabs.net')).to eq(nil)
     end
 
     it 'config exists, and returns' do
-      expect(described_class.config_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('transport' => 'ssh', 'ssh' =>
+      expect(config_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('transport' => 'ssh', 'ssh' =>
 { 'user' => 'root', 'password' => 'Qu@lity!', 'host-key-check' => false })
     end
 
     it 'facts exists, and returns' do
-      expect(described_class.facts_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('provisioner' => 'vmpooler', 'platform' => 'centos-5-x86_64')
+      expect(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(described_class.vars_from_node(config_hash, 'test.delivery.puppetlabs.net')).to eq('role' => 'agent')
+      expect(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(described_class.add_feature_to_group(no_feature_hash, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_group(no_feature_hash, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'feature exists for the group, and returns hash with feature removed' do
-      expect(described_class.remove_feature_from_group(feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => [], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(remove_feature_from_group(feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => [], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'write from inventory_hash to inventory_yaml file feature_hash_group' do
-      expect { described_class.write_to_inventory_file(feature_hash_group, inventory_full_path) }.not_to raise_error
+      expect { write_to_inventory_file(feature_hash_group, inventory_full_path) }.not_to raise_error
     end
 
     it 'empty feature exists for the group, and returns hash with feature added' do
-      expect(described_class.add_feature_to_group(empty_feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_group(empty_feature_hash_group, 'puppet-agent', 'ssh_nodes')).to eq('groups' => [{ 'features' => ['puppet-agent'], 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net' }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'no feature exists for the node, and returns hash with feature added' do
-      expect(described_class.add_feature_to_node(no_feature_hash, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_node(no_feature_hash, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'feature exists for the node, and returns hash with feature removed' do
-      expect(described_class.remove_feature_from_node(feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => [] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(remove_feature_from_node(feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => [] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'write from inventory_hash to inventory_yaml file feature_hash_node' do
-      expect { described_class.write_to_inventory_file(feature_hash_node, inventory_full_path) }.not_to raise_error
+      expect { write_to_inventory_file(feature_hash_node, inventory_full_path) }.not_to raise_error
     end
 
     it 'empty feature exists for the node, and returns hash with feature added' do
-      expect(described_class.add_feature_to_node(empty_feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
+      expect(add_feature_to_node(empty_feature_hash_node, 'puppet-agent', 'test.delivery.puppetlabs.net')).to eq('groups' => [{ 'name' => 'ssh_nodes', 'targets' => [{ 'config' => { 'ssh' => { 'host-key-check' => false, 'password' => 'Qu@lity!', 'user' => 'root' }, 'transport' => 'ssh' }, 'facts' => { 'platform' => 'centos-5-x86_64', 'provisioner' => 'vmpooler' }, 'uri' => 'test.delivery.puppetlabs.net', 'features' => ['puppet-agent'] }] }, { 'name' => 'winrm_nodes', 'targets' => [] }]) # rubocop:disable Layout/LineLength: Line is too long
     end
 
     it 'write from inventory_hash to inventory_yaml file no feature_hash' do
       expect(File).to exist(inventory_full_path)
-      expect { described_class.write_to_inventory_file(no_feature_hash, inventory_full_path) }.not_to raise_error
+      expect { write_to_inventory_file(no_feature_hash, inventory_full_path) }.not_to raise_error
     end
 
     it 'group does not exist in inventory, and returns hash with group added' do
-      expect(described_class.add_node_to_group(no_docker_hash, foo_node, 'docker_nodes')).to eq('groups' =>
+      expect(add_node_to_group(no_docker_hash, foo_node, 'docker_nodes')).to eq('groups' =>
         [{ 'name' => 'ssh_nodes', 'targets' => [] }, { 'name' => 'winrm_nodes', 'targets' => [] }, { 'name' => 'docker_nodes', 'targets' => [foo_node] }])
     end
 
     it 'group exists in inventory, and returns hash with node added' do
-      expect(described_class.add_node_to_group(no_docker_hash, foo_node, 'ssh_nodes')).to eq('groups' =>
+      expect(add_node_to_group(no_docker_hash, foo_node, 'ssh_nodes')).to eq('groups' =>
         [{ 'name' => 'ssh_nodes', 'targets' => [foo_node] }, { 'name' => 'winrm_nodes', 'targets' => [] }])
     end
   end

data/spec/lib/puppet_litmus/puppet_helpers_spec.rb

@@ -13,72 +13,67 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     end
 
     it 'calls all functions' do
-      expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-      expect(described_class).to receive(:apply_manifest).with(nil, expect_failures: false, manifest_file_location: '/bla.pp')
-      expect(described_class).to receive(:apply_manifest).with(nil, catch_changes: true, manifest_file_location: '/bla.pp')
-      described_class.idempotent_apply(manifest)
+      expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+      expect(self).to receive(:apply_manifest).with(nil, expect_failures: false, manifest_file_location: '/bla.pp')
+      expect(self).to receive(:apply_manifest).with(nil, catch_changes: true, manifest_file_location: '/bla.pp')
+      idempotent_apply(manifest)
     end
   end
 
   describe '.apply_manifest' do
     context 'when specifying a hiera config' do
       let(:manifest) { "include '::doot'" }
-      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'" }
+      let(:result) { ['value' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
+      let(:command) { " puppet apply /bla.pp --trace --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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        described_class.apply_manifest(manifest, hiera_config: '/hiera.yaml')
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        apply_manifest(manifest, hiera_config: '/hiera.yaml')
       end
     end
 
     context 'when using detailed-exitcodes' do
       let(:manifest) { "include '::doot'" }
-      let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
-      let(:command) { " puppet apply /bla.pp --modulepath #{Dir.pwd}/spec/fixtures/modules --detailed-exitcodes" }
+      let(:result) { ['value' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
+      let(:command) { " puppet apply /bla.pp --trace --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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.apply_manifest(manifest, expect_failures: true) }.to raise_error(RuntimeError)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { 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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        described_class.apply_manifest(manifest, catch_failures: true)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.apply_manifest(manifest, expect_changes: true) }.to raise_error(RuntimeError)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { 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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
-        expect(described_class).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        described_class.apply_manifest(manifest, catch_changes: true)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:create_manifest_file).with(manifest).and_return('/bla.pp')
+        expect(self).to receive(:run_command).with(command, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        apply_manifest(manifest, catch_changes: true)
       end
 
       it 'uses raises exception for multiple options' do
-        expect { described_class.apply_manifest(manifest, catch_changes: true, expect_failures: true) }
+        expect { 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
@@ -86,20 +81,19 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
 
   describe '.run_shell' do
     let(:command_to_run) { "puts 'doot'" }
-    let(:result) { ['result' => { 'exit_code' => 0, 'exit_status' => 0, 'stdout' => nil, 'stderr' => nil }] }
+    let(:result) { ['value' => { 'exit_code' => 0, 'exit_status' => 0, 'stdout' => nil, 'stderr' => nil }] }
 
     it 'responds to run_shell' do
-      expect(described_class).to respond_to(:run_shell).with(1..2).arguments
+      expect(self).to respond_to(:run_shell).with(1..2).arguments
     end
 
     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(File).to receive(:exist?).with('inventory.yaml').and_return(false)
-        expect(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_command).with(command_to_run, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.run_shell(command_to_run) }.not_to raise_error
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_command).with(command_to_run, 'litmus_localhost', config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { run_shell(command_to_run) }.not_to raise_error
       end
     end
 
@@ -107,10 +101,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers 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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_command).with(command_to_run, 'some.host', config: nil, inventory: inventory_hash).and_return(result)
-        expect { described_class.run_shell(command_to_run) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_command).with(command_to_run, 'some.host', config: nil, inventory: inventory_hash).and_return(result)
+        expect { run_shell(command_to_run) }.not_to raise_error
       end
     end
   end
@@ -120,32 +114,31 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     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) {[{'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'}}}]}
+    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
 
     it 'responds to run_shell' do
-      expect(described_class).to respond_to(:bolt_upload_file).with(2..3).arguments
+      expect(self).to respond_to(:bolt_upload_file).with(2..3).arguments
     end
 
     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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_success)
-        expect { described_class.bolt_upload_file(local, remote) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_success)
+        expect { 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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'litmus_localhost', options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result_success)
-        expect { described_class.bolt_upload_file(local, remote) }.not_to raise_error
+        expect(self).not_to receive(:inventory_hash_from_inventory_file)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'litmus_localhost', options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result_success)
+        expect { bolt_upload_file(local, remote) }.not_to raise_error
       end
     end
 
@@ -153,19 +146,19 @@ RSpec.describe PuppetLitmus::PuppetHelpers 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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
-        expect { described_class.bolt_upload_file(local, remote) }.to raise_error(RuntimeError, %r{upload file failed})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
+        expect { 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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
-        method_result = described_class.bolt_upload_file(local, remote, expect_failures: true)
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:upload_file).with(local, remote, 'some.host', options: {}, config: nil, inventory: inventory_hash).and_return(result_failure)
+        method_result = bolt_upload_file(local, remote, expect_failures: true)
         expect(method_result.exit_code).to be(255)
         expect(method_result.stderr).to be('No such file or directory @ rb_sysopen - /nonexistant/file/path')
       end
@@ -174,21 +167,20 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
 
   describe '.bolt_run_script' do
     let(:script) { '/tmp/script.sh' }
-    let(:result) { ['result' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
+    let(:result) { ['value' => { 'exit_code' => 0, 'stdout' => nil, 'stderr' => nil }] }
 
     it 'responds to bolt_run_script' do
-      expect(described_class).to respond_to(:bolt_run_script).with(1..2).arguments
+      expect(self).to respond_to(:bolt_run_script).with(1..2).arguments
     end
 
     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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'litmus_localhost', [], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.bolt_run_script(script) }.not_to raise_error
+        expect(self).not_to receive(:inventory_hash_from_inventory_file)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_script).with(script, 'litmus_localhost', [], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { bolt_run_script(script) }.not_to raise_error
       end
     end
 
@@ -196,10 +188,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
       it 'does bolt_run_script against remote host without error' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('inventory.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: inventory_hash).and_return(result)
-        expect { described_class.bolt_run_script(script) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: inventory_hash).and_return(result)
+        expect { bolt_run_script(script) }.not_to raise_error
       end
     end
 
@@ -207,11 +199,10 @@ RSpec.describe PuppetLitmus::PuppetHelpers 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(described_class).to receive(:localhost_inventory_hash).and_return(localhost_inventory_hash)
-        expect(described_class).not_to receive(:inventory_hash_from_inventory_file)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'litmus_localhost', ['doot'], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
-        expect { described_class.bolt_run_script(script, arguments: ['doot']) }.not_to raise_error
+        expect(self).not_to receive(:inventory_hash_from_inventory_file)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_script).with(script, 'litmus_localhost', ['doot'], options: {}, config: nil, inventory: localhost_inventory_hash).and_return(result)
+        expect { bolt_run_script(script, arguments: ['doot']) }.not_to raise_error
       end
     end
   end
@@ -222,51 +213,51 @@ RSpec.describe PuppetLitmus::PuppetHelpers do
     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){ [{'node'=>'some.host','target'=>'some.host','action'=>'task','object'=>'testtask::unstructured','status'=>'success','result'=>{'_output'=>'SUCCESS!'}}]}
-    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}}}}]}
+    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
 
     it 'responds to bolt_run_task' do
-      expect(described_class).to respond_to(:run_bolt_task).with(2..3).arguments
+      expect(self).to respond_to(:run_bolt_task).with(2..3).arguments
     end
 
     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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
-        expect { described_class.run_bolt_task(task_name, params, opts: {}) }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
+        expect { run_bolt_task(task_name, params, opts: {}) }.not_to raise_error
       end
 
       it 'does bolt_task_run gives no runtime error for success, for a named inventory file' do
         stub_const('ENV', ENV.to_hash.merge('TARGET_HOST' => 'some.host'))
         expect(File).to receive(:exist?).with('jim.yaml').and_return(true)
-        expect(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
-        expect { described_class.run_bolt_task(task_name, params, inventory_file: 'jim.yaml') }.not_to raise_error
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
+        expect { run_bolt_task(task_name, params, inventory_file: 'jim.yaml') }.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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
-        method_result = described_class.run_bolt_task(task_name, params, opts: {})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_unstructured_task_success)
+        method_result = 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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_structured_task_success)
-        method_result = described_class.run_bolt_task(task_name, params, opts: {})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_structured_task_success)
+        method_result = run_bolt_task(task_name, params, opts: {})
         expect(method_result.stdout).to eq('{"key1"=>"foo", "key2"=>"bar"}')
         expect(method_result.result['key1']).to eq('foo')
         expect(method_result.result['key2']).to eq('bar')
@@ -277,19 +268,19 @@ RSpec.describe PuppetLitmus::PuppetHelpers 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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
-        expect { described_class.run_bolt_task(task_name, params, opts: {}) }.to raise_error(RuntimeError, %r{task failed})
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
+        expect { 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(described_class).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
-        method_result = described_class.run_bolt_task(task_name, params, expect_failures: true)
+        expect(self).to receive(:inventory_hash_from_inventory_file).and_return(inventory_hash)
+        expect(self).to receive(:target_in_inventory?).and_return(true)
+        expect(self).to receive(:run_task).with(task_name, 'some.host', params, config: config_data, inventory: inventory_hash).and_return(result_failure)
+        method_result = run_bolt_task(task_name, params, expect_failures: true)
         expect(method_result.exit_code).to be(123)
         expect(method_result.stderr).to be('FAILURE!')
       end