beaker 4.26.0 → 4.29.0

data/lib/beaker/host/unix/pkg.rb

@@ -5,6 +5,7 @@ module Unix::Pkg
   # unix-specific package management setup
   def pkg_initialize
     @apt_needs_update = true
+    @pacman_needs_update = true
   end
 
   def check_for_command(name)
@@ -71,6 +72,17 @@ module Unix::Pkg
     end
   end
 
+  # Arch Linux is a rolling release distribution. We need to ensure that it is up2date
+  # Except for the kernel. An upgrade will purge the modules for the currently running kernel
+  def update_pacman_if_needed
+    if self['platform'] =~ /archlinux/
+      if @pacman_needs_update
+        execute("pacman --sync --noconfirm --noprogressbar --refresh --sysupgrade --ignore linux --ignore linux-docs --ignore linux-headers")
+        @pacman_needs_update = false
+      end
+    end
+  end
+
   def install_package(name, cmdline_args = '', version = nil, opts = {})
     case self['platform']
       when /sles-/
@@ -138,6 +150,7 @@ module Unix::Pkg
           retry
         end
       when /archlinux/
+        update_pacman_if_needed
         execute("pacman -S --noconfirm #{cmdline_args} #{name}", opts)
       else
         raise "Package #{name} cannot be installed on #{self}"

data/lib/beaker/platform.rb

@@ -6,11 +6,12 @@ module Beaker
     PLATFORMS = /^(alpine|huaweios|cisco_nexus|cisco_ios_xr|(free|open)bsd|osx|centos|fedora|debian|oracle|redhat|redhatfips|scientific|sles|ubuntu|windows|solaris|aix|archlinux|el|eos|cumulus|f5|netscaler)\-.+\-.+$/
     # Platform version numbers vs. codenames conversion hash
     PLATFORM_VERSION_CODES =
-      { :debian => { "buster"  => "10",
-                     "stretch" => "9",
-                     "jessie"  => "8",
-                     "wheezy"  => "7",
-                     "squeeze" => "6",
+      { :debian => { "bullseye"  => "11",
+                     "buster"    => "10",
+                     "stretch"   => "9",
+                     "jessie"    => "8",
+                     "wheezy"    => "7",
+                     "squeeze"   => "6",
                    },
         :ubuntu => { "focal"   => "2004",
                      "eoan"    => "1910",

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '4.26.0'
+    STRING = '4.29.0'
   end
 end

data/spec/beaker/dsl/helpers/web_helpers_spec.rb

@@ -89,6 +89,7 @@ describe ClassMixedWithDSLHelpers do
   describe "#fetch_http_dir" do
     let( :logger) { double("Beaker::Logger", :notify => nil , :debug => nil ) }
     let( :result) { double(:each_line => []) }
+    let( :status) { double('Process::Status', success?: true) }
 
     before do
       fetch_allows
@@ -97,8 +98,7 @@ describe ClassMixedWithDSLHelpers do
     describe "given valid arguments" do
 
       it "returns basename of first argument concatenated to second." do
-        expect(subject).to receive(:`).with(/^wget.*/).ordered { result }
-        expect($?).to receive(:to_i).and_return(0)
+        expect(Open3).to receive(:capture2e).with(/^wget.*/).ordered { result }.and_return(['', status])
         result = subject.fetch_http_dir "#{url}/beep", destdir
         expect(result).to eq("#{destdir}/beep")
       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