beaker 4.23.2 → 4.27.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.23.2'
+    STRING = '4.27.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
@@ -99,5 +98,59 @@ module Beaker
           to be == "set \"LD_PATH=/:/tmp\" && "
       end
     end
+
+    describe '#which' do
+      before do
+        allow(instance).to receive(:execute)
+                               .with(where_command, :accept_all_exit_codes => true).and_return(result)
+      end
+      let(:where_command) { "cmd /C \"where ruby\"" }
+
+      context 'when only the environment variable PATH is used' do
+        let(:result) { "C:\\Ruby26-x64\\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) { "cmd /C \"where 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
+
+    describe '#mkdir_p' do
+        let(:dir_path) { "C:\\tmpdir\\my_dir" }
+        let(:beaker_command) { instance_spy(Beaker::Command) }
+        let(:command) {"-Command New-Item -Path '#{dir_path}' -ItemType 'directory'"}
+        let(:result) { instance_spy(Beaker::Result) }
+
+        before do
+          allow(Beaker::Command).to receive(:new).
+              with('powershell.exe', array_including(command)).and_return(beaker_command)
+          allow(instance).to receive(:exec).with(beaker_command, :acceptable_exit_codes => [0, 1]).and_return(result)
+        end
+
+        it 'returns true and creates folder structure' do
+          allow(result).to receive(:exit_code).and_return(0)
+
+          expect(instance.mkdir_p(dir_path)).to be(true)
+        end
+
+        it 'returns false if failed to create directory structure' do
+          allow(result).to receive(:exit_code).and_return(1)
+
+          expect(instance.mkdir_p(dir_path)).to be(false)
+        end
+      end
   end
 end

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

@@ -25,11 +25,31 @@ module Beaker
     let (:instance) { PSWindowsFileTest.new(opts, logger) }
 
     describe '#cat' do
+      let(:path) { '/path/to/cat' }
+      let(:content) { 'file content' }
       it 'reads output for file' do
-        path = '/path/to/delete'
-        expect(instance).to receive(:exec)
+        expect(instance).to receive(:exec).and_return(double(stdout: content))
         expect(Beaker::Command).to receive(:new).with('powershell.exe', array_including("-Command type #{path}"))
-        instance.cat(path)
+        expect(instance.cat(path)).to eq(content)
+      end
+    end
+
+    describe '#file_exist?' do
+      let(:path) { '/path/to/test/file.txt' }
+      context 'file exists' do
+        it 'returns true' do
+          expect(instance).to receive(:exec).and_return(double(stdout: "true\n"))
+          expect(Beaker::Command).to receive(:new).with("if exist #{path} echo true")
+          expect(instance.file_exist?(path)).to eq(true)
+        end
+      end
+
+      context 'file does not exist' do
+        it 'returns false' do
+          expect(instance).to receive(:exec).and_return(double(stdout: ""))
+          expect(Beaker::Command).to receive(:new).with("if exist #{path} echo true")
+          expect(instance.file_exist?(path)).to eq(false)
+        end
       end
     end
 
@@ -39,7 +59,6 @@ module Beaker
 
       before do
         allow(instance).to receive(:execute).with(anything)
-
       end
 
       context 'with dirname sent' do

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

@@ -169,6 +169,64 @@ module Beaker
     end
 
     describe '#reboot' do
+      check_cmd_output = {
+        :centos6 => {
+          :who => {
+            :initial => '      system boot  2020-05-13 03:51',
+            :success => '      system boot  2020-05-13 03:52',
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  2.6.32-754.29.1. Tue May 5 17:34:52 2020 - Tue May 5 17:52:48 2020  (00:17)
+              reboot   system boot  2.6.32-754.29.1. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  2.6.32-754.29.1. Tue May 5 17:52:48 2020 - Tue May 5 17:52:49 2020  (00:17)
+              reboot   system boot  2.6.32-754.29.1. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+          },
+        },
+        :centos7 => {
+          :who => {
+            :initial => '      system boot  2020-05-13 03:51',
+            :success => '      system boot  2020-05-13 03:52',
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  3.10.0-1127.el7. Tue May 5 17:34:52 2020 - Tue May 5 17:52:48 2020  (00:17)
+              reboot   system boot  3.10.0-1127.el7. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  3.10.0-1127.el7. Tue May 5 17:52:48 2020 - Tue May 5 17:52:49 2020  (00:17)
+              reboot   system boot  3.10.0-1127.el7. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+          },
+        },
+        :centos8 => {
+          :who => {
+            :initial => '      system boot  2020-05-13 03:51',
+            :success => '      system boot  2020-05-13 03:52',
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  4.18.0-147.8.1.e Tue May 5 17:34:52 2020 still running
+              reboot   system boot  4.18.0-147.8.1.e Mon May 4 17:41:27 2020 - Tue May 5 17:00:00 2020 (5+00:11)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  4.18.0-147.8.1.e Tue May 5 17:34:53 2020 still running
+              reboot   system boot  4.18.0-147.8.1.e Mon May 4 17:41:27 2020 - Tue May 5 17:00:00 2020 (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 +237,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 +248,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)
+                # 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
 
-        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' }
 
-                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
+                    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(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
@@ -313,40 +383,32 @@ module Beaker
 
     end
 
-    describe '#parse_uptime' do
-      it 'parses variation of uptime string' do
-        expect(instance.parse_uptime("19:52  up 14 mins, 2 users, load averages: 2.95 4.19 4.31")).to be == "14 mins"
-      end
-      it 'parses variation 2 of uptime string' do
-        expect(instance.parse_uptime("8:03 up 52 days, 20:47, 3 users, load averages: 1.36 1.42 1.40")).to be == "52 days, 20:47"
-      end
-      it 'parses variation 3 of uptime string' do
-        expect(instance.parse_uptime("22:19 up 54 days, 1 min, 4 users, load averages: 2.08 2.06 2.27")).to be == "54 days, 1 min"
+    describe '#which' do
+      before do
+        allow(instance).to receive(:execute)
+                               .with(where_command, :accept_all_exit_codes => true).and_return(result)
       end
-      it 'parses variation 4 of uptime string' do
-        expect(instance.parse_uptime("18:44:45 up 5 min,  0 users,  load average: 0.14, 0.11, 0.05")).to be == "5 min"
-      end
-      it 'parses solaris\'s "just up" without time message' do
-        opts['platform'] = 'solaris-11-x86_64'
-        expect(instance.parse_uptime("10:05am  up  0 users,  load average: 0.66, 0.14, 0.05")).to be == "0 min"
-      end
-     end
 
-    describe '#uptime_int' do
-      it 'parses time segment variation into a minute value' do
-        expect(instance.uptime_int("14 mins")).to be == 14
-      end
-      it 'parses time segment variation 2 into a minute value' do
-        expect(instance.uptime_int("52 days, 20:47")).to be == 76127
-      end
-      it 'parses time segment variation 3 into a minute value' do
-        expect(instance.uptime_int("54 days, 1 min")).to be == 77761
+      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
-      it 'parses time segment variation 4 into a minute value' do
-        expect(instance.uptime_int("54 days")).to be == 77760
       end
-      it 'raises if we pass garbage to it' do
-        expect { instance.uptime_int("solaris roxx my soxx") }.to raise_error
+
+      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
   end