puppet_litmus 0.16.0 → 0.18.3

data/lib/puppet_litmus/version.rb

@@ -2,5 +2,5 @@
 
 # version of this gem
 module PuppetLitmus
-  VERSION ||= '0.16.0'
+  VERSION ||= '0.18.3'
 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

@@ -3,80 +3,77 @@
 require 'spec_helper'
 
 RSpec.describe PuppetLitmus::PuppetHelpers do
+  let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'targets' => [{ 'uri' => 'some.host', 'config' => { 'transport' => 'local' }, 'facts' => facts_hash }] }] } }
+  let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'targets' => [{ 'uri' => 'litmus_localhost', 'config' => { 'transport' => 'local' }, 'facts' => facts_hash }] }] } }
+  let(:facts_hash) { { 'provisioner' => 'docker', 'container_name' => 'litmusimage_debian_10-2222', 'platform' => 'litmusimage/debian:10' } }
+
   context 'with idempotent_apply' do
     let(:manifest) do
       "include '::doot'"
     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(: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'" }
+      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(: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" }
+      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
@@ -84,22 +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(:inventory_hash) { { 'groups' => [{ 'name' => 'ssh_nodes', 'nodes' => [{ 'name' => 'some.host' }] }] } }
-    let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
+    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,34 +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
-    let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'some.host', 'config' => { 'transport' => 'local' } }] }] } }
-    let(:localhost_inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'litmus_localhost', 'config' => { 'transport' => 'local' } }] }] } }
 
     it 'responds to run_shell' do
-      expect(described_class).to respond_to(:bolt_upload_file).with(2..3).arguments
+      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
 
@@ -155,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
@@ -176,23 +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(: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' } }] }] } }
+    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
 
@@ -200,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)
-        expect(described_class).to receive(:target_in_inventory?).and_return(true)
-        expect(described_class).to receive(:run_script).with(script, 'some.host', [], options: {}, config: nil, inventory: nil).and_return(result)
-        expect { described_class.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
 
@@ -211,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
@@ -226,52 +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
-    let(:inventory_hash) { { 'groups' => [{ 'name' => 'local', 'nodes' => [{ 'name' => 'some.host', 'config' => { 'transport' => 'local' } }] }] } }
 
     it 'responds to bolt_run_task' do
-      expect(described_class).to respond_to(:run_bolt_task).with(2..3).arguments
+      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')
@@ -282,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