beaker 4.25.0 → 4.28.1

data/lib/beaker/ssh_connection.rb

@@ -69,8 +69,13 @@ module Beaker
       begin
          @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
 
+         # Work around net-ssh 6+ incompatibilities
          if ssh_opts.include?(:strict_host_key_checking) && (Net::SSH::Version::CURRENT.major > 5)
-           ssh_opts[:paranoid] = ssh_opts.delete(:strict_host_key_checking)
+           strict_host_key_checking = ssh_opts.delete(:strict_host_key_checking)
+
+           unless ssh_opts[:verify_host_key].is_a?(Symbol)
+             ssh_opts[:verify_host_key] ||= strict_host_key_checking ? :always : :never
+           end
          end
 
          Net::SSH.start(host, user, ssh_opts)

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '4.25.0'
+    STRING = '4.28.1'
   end
 end

data/spec/beaker/host/pswindows/exec_spec.rb

@@ -29,8 +29,8 @@ module Beaker
       it "deletes" do
         path = '/path/to/delete'
         corrected_path = '\\path\\to\\delete'
-        expect( instance ).to receive(:execute).with("del /s /q #{corrected_path}").and_return(0)
-        expect( instance.rm_rf(path) ).to be === 0
+        expect(instance).to receive(:execute).with(%(del /s /q "#{corrected_path}")).and_return(0)
+        expect(instance.rm_rf(path)).to eq(0)
       end
     end
 
@@ -39,10 +39,9 @@ module Beaker
       let(:destination) { '/destination/path/of/content' }
 
       it 'rm first' do
-        expect( instance ).to receive(:execute).with("del /s /q #{destination.gsub(/\//, '\\')}").and_return(0)
-        expect( instance ).to receive(:execute).with("move /y #{origin.gsub(/\//, '\\')} #{destination.gsub(/\//, '\\')}").and_return(0)
-        expect( instance.mv(origin, destination) ).to be === 0
-
+        expect(instance).to receive(:execute).with("del /s /q \"\\destination\\path\\of\\content\"").and_return(0)
+        expect(instance).to receive(:execute).with("move /y #{origin.gsub(/\//, '\\')} #{destination.gsub(/\//, '\\')}").and_return(0)
+        expect(instance.mv(origin, destination)).to eq(0)
       end
 
       it 'does not rm' do

data/spec/beaker/host/unix/exec_spec.rb

@@ -169,6 +169,66 @@ module Beaker
     end
 
     describe '#reboot' do
+      year = Time.now.strftime('%Y')
+
+      check_cmd_output = {
+        :centos6 => {
+          :who => {
+            :initial => "      system boot  #{year}-05-13 03:51",
+            :success => "      system boot  #{year}-05-13 03:52",
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  2.6.32-754.29.1. Tue May 5 17:34:52 #{year} - Tue May 5 17:52:48 #{year}  (00:17)
+              reboot   system boot  2.6.32-754.29.1. Mon May 4 18:45:43 #{year} - Mon May 5 05:35:44 #{year} (4+01:50)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  2.6.32-754.29.1. Tue May 5 17:52:48 #{year} - Tue May 5 17:52:49 #{year}  (00:17)
+              reboot   system boot  2.6.32-754.29.1. Mon May 4 18:45:43 #{year} - Mon May 5 05:35:44 #{year} (4+01:50)
+              LAST_F
+          },
+        },
+        :centos7 => {
+          :who => {
+            :initial => "      system boot  #{year}-05-13 03:51",
+            :success => "      system boot  #{year}-05-13 03:52",
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  3.10.0-1127.el7. Tue May 5 17:34:52 #{year} - Tue May 5 17:52:48 #{year}  (00:17)
+              reboot   system boot  3.10.0-1127.el7. Mon May 4 18:45:43 #{year} - Mon May 5 05:35:44 #{year} (4+01:50)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  3.10.0-1127.el7. Tue May 5 17:52:48 #{year} - Tue May 5 17:52:49 #{year}  (00:17)
+              reboot   system boot  3.10.0-1127.el7. Mon May 4 18:45:43 #{year} - Mon May 5 05:35:44 #{year} (4+01:50)
+              LAST_F
+          },
+        },
+        :centos8 => {
+          :who => {
+            :initial => "      system boot  #{year}-05-13 03:51",
+            :success => "      system boot  #{year}-05-13 03:52",
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  4.18.0-147.8.1.e Tue May 5 17:34:52 #{year} still running
+              reboot   system boot  4.18.0-147.8.1.e Mon May 4 17:41:27 #{year} - Tue May 5 17:00:00 #{year} (5+00:11)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  4.18.0-147.8.1.e Tue May 5 17:34:53 #{year} still running
+              reboot   system boot  4.18.0-147.8.1.e Mon May 4 17:41:27 #{year} - Tue May 5 17:00:00 #{year} (5+00:11)
+              LAST_F
+          },
+        },
+        :freebsd => {
+          # last -F doesn't work on freebsd so no output will be returned
+          :who => {
+            :initial => '      system boot  May 13 03:51',
+            :success => '      system boot  May 13 03:52',
+          }
+        },
+      }
+
       # no-op response
       let (:response) { double( 'response' ) }
       let (:boot_time_initial_response) { double( 'response' ) }
@@ -179,7 +239,7 @@ module Beaker
       before :each do
         # stubs enough to survive the first boot_time call & output parsing
         #   note: just stubs input-chain between calls, parsing methods still run
-        allow(Beaker::Command).to receive(:new).with('who -b').and_return(:boot_time_command_stub)
+        allow(Beaker::Command).to receive(:new).with('last -F reboot || who -b').and_return(:boot_time_command_stub)
 
         allow(boot_time_initial_response).to receive(:stdout).and_return(boot_time_initial_stdout)
         allow(boot_time_success_response).to receive(:stdout).and_return(boot_time_success_stdout)
@@ -190,116 +250,128 @@ module Beaker
       end
 
       context 'new boot time greater than old boot time' do
-        let (:boot_time_initial_stdout) { '      system boot  2020-05-13 03:51' }
-        let (:boot_time_success_stdout) { '      system boot  2020-05-13 03:52' }
-
-        it 'passes with defaults' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response)
-          # allow the second boot_time and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
-
-          expect(instance.reboot).to be(nil)
-        end
+        check_cmd_output.each do |check_os, cmd_opts|
+          cmd_opts.each do |cmd_name, cmd_outputs|
+            context "on '#{check_os}' with the '#{cmd_name}' command" do
+              let (:boot_time_initial_stdout) { cmd_outputs[:initial] }
+              let (:boot_time_success_stdout) { cmd_outputs[:success] }
+
+              it 'passes with defaults' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response)
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                # allow the second boot_time and the hash arguments in exec
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-        it 'passes with wait_time_parameter' do
-          expect(instance).to receive(:sleep).with(10)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
+                expect(instance.reboot).to be(nil)
+              end
 
-          expect(instance.reboot(10)).to be(nil)
-        end
+              it 'passes with wait_time_parameter' do
+                expect(instance).to receive(:sleep).with(10)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                # allow the second boot_time and the hash arguments in exec
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-        it 'passes with max_connection_tries parameter' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, hash_including(:max_connection_tries => 20)).and_return(boot_time_success_response).once
+                expect(instance.reboot(10)).to be(nil)
+              end
 
-          expect(instance.reboot(sleep_time, 20)).to be(nil)
-        end
+              it 'passes with max_connection_tries parameter' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                # allow the second boot_time and the hash arguments in exec
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, hash_including(:max_connection_tries => 20)).and_return(boot_time_success_response).once
 
-        context 'command errors' do
-          before :each do
-            allow(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          end
+                expect(instance.reboot(sleep_time, 20)).to be(nil)
+              end
 
-          it 'raises a reboot failure when command fails' do
-            expect(instance).not_to receive(:sleep)
-            expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Host::CommandFailure).once
+              context 'command errors' do
+                before :each do
+                  allow(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).at_least(:once)
+                end
 
-            expect{ instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Command failed when attempting to reboot: .*/)
-          end
+                it 'raises a reboot failure when command fails' do
+                  expect(instance).to receive(:sleep).at_least(:once)
+                  expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Host::CommandFailure).at_least(:once)
 
-          it 'raises a reboot failure when we receive an unexpected error' do
-            expect(instance).not_to receive(:sleep)
-            expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Net::SSH::HostKeyError).once
+                  expect{ instance.reboot }.to raise_error(Beaker::Host::CommandFailure)
+                end
 
-            expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unexpected exception in reboot: .*/)
-          end
+                it 'raises a reboot failure when we receive an unexpected error' do
+                  expect(instance).to receive(:sleep).at_least(:once)
+                  expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Net::SSH::HostKeyError).at_least(:once)
 
-          context 'incorrect time string' do
-            context 'original time' do
-              let (:boot_time_initial_stdout) { 'boot bad' }
+                  expect { instance.reboot }.to raise_error(Net::SSH::HostKeyError)
+                end
 
-              it 'raises a reboot failure' do
-                expect(instance).not_to receive(:sleep)
+                context 'incorrect time string' do
+                  context 'original time' do
+                    let (:boot_time_initial_stdout) { 'boot bad' }
 
-                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
-              end
-            end
+                    it 'raises a reboot failure' do
+                      # Handle the 'retry'
+                      allow(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).at_least(:once)
 
-            context 'current time' do
-              let (:boot_time_success_stdout) { 'boot bad' }
+                      expect(instance).not_to receive(:sleep)
 
-              it 'raises a reboot failure' do
-                expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_return(response).once
-                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-                # allow the second boot_time and the hash arguments in exec, repeated 10 times by default
-                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
+                      expect { instance.reboot }.to raise_error(Beaker::Host::RebootWarning, /Found no valid times in .*/)
+                    end
+                  end
+
+                  context 'current time' do
+                    let (:boot_time_success_stdout) { 'boot bad' }
+
+                    it 'raises a reboot failure' do
+                      expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_return(response).once
+                      expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                      # allow the second boot_time and the hash arguments in exec, repeated 10 times by default
+                      expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).at_least(:once)
 
-                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
+                      expect { instance.reboot(10,9,1) }.to raise_error(Beaker::Host::RebootWarning, /Found no valid times in .*/)
+                    end
+                  end
+                end
               end
             end
           end
         end
       end
 
-      context 'new boot time less than old boot time' do
-        let (:boot_time_initial_stdout) { '      system boot  2020-05-13 03:51' }
-        let (:boot_time_success_stdout) { '      system boot  2020-05-13 03:50' }
+      context 'system did not reboot' do
+        check_cmd_output.each do |check_os, cmd_opts|
+          cmd_opts.each do |cmd_name, cmd_outputs|
+            context "on '#{check_os}' with the '#{cmd_name}' command" do
+              let (:boot_time_initial_stdout) { cmd_outputs[:initial] }
+              let (:boot_time_success_stdout) { cmd_outputs[:initial] }
 
-        it 'raises RebootFailure' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+              it 'raises RebootFailure' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
 
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec, repeated 18 times by default in order to replicate the previous behavior of the ping based Host.down?
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).exactly(18).times
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-          expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
-        end
+                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
+              end
 
-        it 'raises RebootFailure if the number of retries is changed' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec, repeated 10 times by default
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).exactly(10).times
+              it 'raises RebootFailure if the number of retries is changed' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-          expect { instance.reboot(wait_time=sleep_time, max_connection_tries=9, boot_time_retries=10) }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
+                expect { instance.reboot(wait_time=sleep_time, max_connection_tries=9, boot_time_retries=10) }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
+              end
+            end
+          end
         end
       end
-
     end
 
     describe '#enable_remote_rsyslog' do
@@ -314,30 +386,86 @@ module Beaker
     end
 
     describe '#which' do
-      before do
-        allow(instance).to receive(:execute)
-                               .with(where_command, :accept_all_exit_codes => true).and_return(result)
+      context 'when type -P works' do
+        before do
+          expect(instance).to receive(:execute)
+            .with('type -P true', :accept_all_exit_codes => true).and_return('/bin/true').once
+
+          allow(instance).to receive(:execute)
+                                 .with(where_command, :accept_all_exit_codes => true).and_return(result)
+        end
+
+        context 'when only the environment variable PATH is used' do
+          let(:where_command) { "type -P ruby" }
+          let(:result) { "/usr/bin/ruby.exe" }
+
+          it 'returns the correct path' do
+            response = instance.which('ruby')
+
+            expect(response).to eq(result)
+          end
+        end
+
+        context 'when command is not found' do
+          let(:where_command) { "type -P unknown" }
+          let(:result) { '' }
+
+          it 'return empty string if command is not found' do
+            response = instance.which('unknown')
+
+            expect(response).to eq(result)
+          end
+        end
       end
 
-      context 'when only the environment variable PATH is used' do
-        let(:where_command) { "which ruby" }
-        let(:result) { "/usr/bin/ruby.exe" }
+      context 'when which works' do
+        before do
+          expect(instance).to receive(:execute)
+            .with('type -P true', :accept_all_exit_codes => true).and_return('').once
 
-        it 'returns the correct path' do
-          response = instance.which('ruby')
+          expect(instance).to receive(:execute)
+            .with('which true', :accept_all_exit_codes => true).and_return('/bin/true').once
 
-          expect(response).to eq(result)
+          allow(instance).to receive(:execute)
+                                 .with(where_command, :accept_all_exit_codes => true).and_return(result)
+        end
+
+        context 'when only the environment variable PATH is used' do
+          let(:where_command) { "which ruby" }
+          let(:result) { "/usr/bin/ruby.exe" }
+
+          it 'returns the correct path' do
+            response = instance.which('ruby')
+
+            expect(response).to eq(result)
+          end
+        end
+
+        context 'when command is not found' do
+          let(:where_command) { "which unknown" }
+          let(:result) { '' }
+
+          it 'return empty string if command is not found' do
+            response = instance.which('unknown')
+
+            expect(response).to eq(result)
+          end
         end
       end
 
-      context 'when command is not found' do
-        let(:where_command) { "which unknown" }
-        let(:result) { '' }
+      context 'when neither works' do
+        before do
+          expect(instance).to receive(:execute)
+            .with('type -P true', :accept_all_exit_codes => true).and_return('').once
 
-        it 'return empty string if command is not found' do
-          response = instance.which('unknown')
+          expect(instance).to receive(:execute)
+            .with('which true', :accept_all_exit_codes => true).and_return('').once
+        end
 
-          expect(response).to eq(result)
+        context 'when only the environment variable PATH is used' do
+          it 'fails correctly' do
+            expect{instance.which('ruby')}.to raise_error(/suitable/)
+          end
         end
       end
     end

data/spec/beaker/options/subcommand_options_parser_spec.rb

@@ -4,8 +4,9 @@ module Beaker
   module Options
     describe '#parse_subcommand_options' do
       let(:home_options_file_path) {ENV['HOME']+'/.beaker/subcommand_options.yaml'}
-      let( :parser ) {Beaker::Options::SubcommandOptionsParser.parse_subcommand_options(argv, options_file)}
-      let( :file_parser ){Beaker::Options::SubcommandOptionsParser.parse_options_file({})}
+      let(:parser_mod) { Beaker::Options::SubcommandOptionsParser }
+      let( :parser ) {parser_mod.parse_subcommand_options(argv, options_file)}
+      let( :file_parser ){parser_mod.parse_options_file({})}
       let( :argv ) {[]}
       let( :options_file ) {""}
 
@@ -26,14 +27,14 @@ module Beaker
         let( :argv ) {['provision']}
         let(:options_file) {Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS}
         it 'calls parse_options_file with subcommand options file when home_dir is false' do
-          allow(parser).to receive(:execute_subcommand?).with('provision').and_return true
-          allow(parser).to receive(:parse_options_file).with(Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS)
+          allow(parser_mod).to receive(:execute_subcommand?).with('provision').and_return true
+          allow(parser_mod).to receive(:parse_options_file).with(Beaker::Subcommands::SubcommandUtil::SUBCOMMAND_OPTIONS)
         end
 
         let( :options_file ) {home_options_file_path}
         it 'calls parse_options_file with home directory options file when home_dir is true' do
-          allow(parser).to receive(:execute_subcommand?).with('provision').and_return true
-          allow(parser).to receive(:parse_options_file).with(home_options_file_path)
+          allow(parser_mod).to receive(:execute_subcommand?).with('provision').and_return true
+          allow(parser_mod).to receive(:parse_options_file).with(home_options_file_path)
         end
 
         it 'checks for file existence and loads the YAML file' do
@@ -49,8 +50,7 @@ module Beaker
           expect(parser).to be_kind_of(OptionsHash)
           expect(parser).to be_empty
         end
-
       end
     end
   end
-end
+end