puppet_litmus 0.18.0 → 0.19.0

data/spec/lib/puppet_litmus/puppet_helpers_spec.rb

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

data/spec/lib/puppet_litmus/rake_helper_spec.rb

@@ -13,12 +13,12 @@ RSpec.shared_examples 'supported provisioner' do |args|
   it 'calls function' do
     allow(File).to receive(:directory?).and_call_original
     allow(File).to receive(:directory?)
-      .with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
+      .with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision'))
       .and_return(true)
     allow_any_instance_of(BoltSpec::Run).to receive(:run_task)
-      .with("provision::#{provisioner}", 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil)
+      .with("provision::#{provisioner}", 'localhost', params, config: described_class::DEFAULT_CONFIG_DATA, inventory: nil)
       .and_return(results)
-    result = described_class.provision(provisioner, platform, inventory_vars)
+    result = provision(provisioner, platform, inventory_vars)
     expect(result).to eq(results)
   end
 end
@@ -29,8 +29,8 @@ RSpec.describe PuppetLitmus::RakeHelper do
     let(:results) { [] }
 
     it 'calls function' do
-      expect(described_class).to receive(:provision).with('docker', 'waffleimage/centos7', nil).and_return(results)
-      described_class.provision_list(provision_hash, 'default')
+      expect(self).to receive(:provision).with('docker', 'waffleimage/centos7', nil).and_return(results)
+      provision_list(provision_hash, 'default')
     end
   end
 
@@ -71,9 +71,9 @@ RSpec.describe PuppetLitmus::RakeHelper do
     let(:params) { { 'action' => 'tear_down', 'node_name' => 'some.host', 'inventory' => Dir.pwd } }
 
     it 'calls function' do
-      allow(File).to receive(:directory?).with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
-      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('provision::docker', 'localhost', params, config: DEFAULT_CONFIG_DATA, inventory: nil).and_return([])
-      described_class.tear_down_nodes(targets, inventory_hash)
+      allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'provision')).and_return(true)
+      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('provision::docker', 'localhost', params, config: described_class::DEFAULT_CONFIG_DATA, inventory: nil).and_return([])
+      tear_down_nodes(targets, inventory_hash)
     end
   end
 
@@ -87,9 +87,9 @@ RSpec.describe PuppetLitmus::RakeHelper do
     let(:params) { { 'collection' => 'puppet6' } }
 
     it 'calls function' do
-      allow(File).to receive(:directory?).with(File.join(DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent')).and_return(true)
-      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('puppet_agent::install', targets, params, config: DEFAULT_CONFIG_DATA, inventory: inventory_hash).and_return([])
-      described_class.install_agent('puppet6', targets, inventory_hash)
+      allow(File).to receive(:directory?).with(File.join(described_class::DEFAULT_CONFIG_DATA['modulepath'], 'puppet_agent')).and_return(true)
+      allow_any_instance_of(BoltSpec::Run).to receive(:run_task).with('puppet_agent::install', targets, params, config: described_class::DEFAULT_CONFIG_DATA, inventory: inventory_hash).and_return([])
+      install_agent('puppet6', targets, inventory_hash)
     end
   end
 
@@ -100,20 +100,20 @@ RSpec.describe PuppetLitmus::RakeHelper do
         [{ 'name' => 'ssh_nodes', 'targets' =>
           [{ 'uri' => 'some.host', 'facts' => { 'provisioner' => 'docker', 'container_name' => 'foo', 'platform' => 'some.host' } }] }] }
     end
-    let(:module_tar) { '/tmp/foo.tar.gz' }
+    let(:module_tar) { 'foo.tar.gz' }
     let(:targets) { ['some.host'] }
     let(:uninstall_module_command) { 'puppet module uninstall foo --force' }
-    let(:install_module_command) { "puppet module install --module_repository 'https://forgeapi.puppetlabs.com' #{module_tar}" }
+    let(:install_module_command) { "puppet module install --module_repository 'https://forgeapi.example.com' #{module_tar}" }
 
     it 'calls function' do
       allow_any_instance_of(BoltSpec::Run).to receive(:upload_file).with(module_tar, module_tar, targets, options: {}, config: nil, inventory: inventory_hash).and_return([])
       allow(File).to receive(:exist?).with(File.join(Dir.pwd, 'metadata.json')).and_return(true)
       allow(File).to receive(:read).with(File.join(Dir.pwd, 'metadata.json')).and_return(JSON.dump({ name: 'foo' }))
-      allow(Open3).to receive(:capture3).with("bundle exec bolt file upload \"#{module_tar}\" /tmp/#{File.basename(module_tar)} --targets all --inventoryfile inventory.yaml")
+      allow(Open3).to receive(:capture3).with("bundle exec bolt file upload \"#{module_tar}\" #{File.basename(module_tar)} --targets all --inventoryfile inventory.yaml")
                                         .and_return(['success', '', 0])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(uninstall_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(install_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
-      described_class.install_module(inventory_hash, nil, module_tar)
+      install_module(inventory_hash, nil, module_tar, 'https://forgeapi.example.com')
     end
   end
 
@@ -129,12 +129,12 @@ RSpec.describe PuppetLitmus::RakeHelper do
     it 'node available' do
       allow(Open3).to receive(:capture3).with('cd .').and_return(['success', '', 0])
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(command, targets, config: nil, inventory: inventory_hash).and_return([{ 'target' => 'some.host', 'status' => 'success' }])
-      described_class.check_connectivity?(inventory_hash, 'some.host')
+      check_connectivity?(inventory_hash, 'some.host')
     end
 
     it 'node unavailable' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(command, targets, config: nil, inventory: inventory_hash).and_return([{ 'target' => 'some.host', 'status' => 'failure' }])
-      expect { described_class.check_connectivity?(inventory_hash, 'some.host') }.to raise_error(RuntimeError, %r{Connectivity has failed on:})
+      expect { check_connectivity?(inventory_hash, 'some.host') }.to raise_error(RuntimeError, %r{Connectivity has failed on:})
     end
   end
 
@@ -149,13 +149,13 @@ RSpec.describe PuppetLitmus::RakeHelper do
 
     it 'uninstalls module' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(uninstall_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
-      expect(described_class).to receive(:metadata_module_name).and_return('foo-bar')
-      described_class.uninstall_module(inventory_hash, nil)
+      expect(self).to receive(:metadata_module_name).and_return('foo-bar')
+      uninstall_module(inventory_hash, nil)
     end
 
     it 'and custom name' do
       allow_any_instance_of(BoltSpec::Run).to receive(:run_command).with(uninstall_module_command, targets, config: nil, inventory: inventory_hash).and_return([])
-      described_class.uninstall_module(inventory_hash, nil, 'foo-bar')
+      uninstall_module(inventory_hash, nil, 'foo-bar')
     end
   end
 
@@ -165,7 +165,7 @@ RSpec.describe PuppetLitmus::RakeHelper do
     it 'reads module name' do
       allow(File).to receive(:exist?).with(File.join(Dir.pwd, 'metadata.json')).and_return(true)
       allow(File).to receive(:read).with(File.join(Dir.pwd, 'metadata.json')).and_return(metadata)
-      name = described_class.metadata_module_name
+      name = metadata_module_name
       expect(name).to eq('foo-bar')
     end
   end
@@ -173,12 +173,12 @@ RSpec.describe PuppetLitmus::RakeHelper do
   context 'with provisioner_task' do
     described_class::SUPPORTED_PROVISIONERS.each do |supported_provisioner|
       it "returns supported provisioner task name for #{supported_provisioner}" do
-        expect(described_class.provisioner_task(supported_provisioner)).to eq("provision::#{supported_provisioner}")
+        expect(provisioner_task(supported_provisioner)).to eq("provision::#{supported_provisioner}")
       end
     end
 
     it 'returns an unsupported provisioner name' do
-      expect(described_class.provisioner_task('my_org::custom_provisioner')).to eql('my_org::custom_provisioner')
+      expect(provisioner_task('my_org::custom_provisioner')).to eql('my_org::custom_provisioner')
     end
   end
 end