beaker 4.22.0 → 4.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f4ee75a711cc94d5814ed063880f947c8529b62bdd992eb5c867af160940655
-  data.tar.gz: 63d0cdbd54c8693e25b7d2b6b81d26bc8403f1736442624417d9c70674a7d06c
+  metadata.gz: a564a311561c124625926ad527bf42a3fe0681e3a0a1c8f7780217a6b00f82dc
+  data.tar.gz: 27c0f8cbae1a3f30226cb1dbc08db0cb4464e9e6340114b2b49d13b66e79d587
 SHA512:
-  metadata.gz: 990c909cc18aa7634f56a0c98573025c3f4a41f6bd0057936c7086a961a55b3ba7e87bd0e9326316ad86c3d843ac3a637ad48eac95ce8cf2bcf61d647af5f477
-  data.tar.gz: 85d6f87e4a62e744911e3b616dc3ec34d6e42d1564664d02e9e09dd915163b9c7d30dd66224d274a58a9ae970497b4ea5766a5da4822530300ad15b80b61c44e
+  metadata.gz: 2f5c86fd2c82c44dd258d952d404741281a502dc2a2f987014795e940aa7e1f5f56937b628fe62a3fba8105a9f12866bd6a1a1367859f6ab9acbf6b7224d8d42
+  data.tar.gz: 095358374f8ff2dfe5c0d95c41d5ff6ac621f69ef95a58580c7151d8f7d13bdbd89e0afa5b70be25ce0f3e14121b56c668765c78705bfe9868233cee37feb687

data/CHANGELOG.md

@@ -20,7 +20,54 @@ The headers used in [Keep a Changelog](http://keepachangelog.com) are:
 - Fixed - for any bug fixes.
 - Security - in case of vulnerabilities.
 
-# [Unreleased](https://github.com/puppetlabs/beaker/compare/4.22.0...master)
+# [Unreleased](https://github.com/puppetlabs/beaker/compare/4.23.2...master)
+
+# [4.24.0](https://github.com/puppetlabs/beaker/compare/4.23.0...4.24.0) - 2020-06-05
+
+### Added
+
+- Host method which ([#1651](https://github.com/puppetlabs/beaker/pull/1651))
+
+### Fixed
+
+- Fixed implementation for cat and file_exists? host methods for PSWindows ([#1654](https://github.com/puppetlabs/beaker/pull/1654))
+- Fixed implementation for mkdir_p host method for PSWindows ([#1657](https://github.com/puppetlabs/beaker/pull/1657))
+
+# [4.23.2](https://github.com/puppetlabs/beaker/compare/4.23.1...4.23.2)
+
+### Fixed
+
+- Fixed Beaker's behavior when the `strict_host_key_checking` option is
+  provided in the SSH config and Net-SSH > 5 is specified. (#1652)
+
+# [4.23.1](https://github.com/puppetlabs/beaker/compare/4.23.0...4.23.1)
+
+### Changed/Removed
+
+- Reversed the quoting changes on Unix from #1644 in favor of only quoting on Windows. (#1650)
+
+# [4.23.0](https://github.com/puppetlabs/beaker/compare/4.22.1...4.23.0)
+
+### Added
+
+- Relaxed dependency on `net-ssh` to `>= 5` to support newer versions. (#1648)
+- `cat` DSL method added. Works on both Unix and Windows hosts. (#1645)
+
+### Changed
+
+- The `mkdir_p` and `mv` commands now double quote their file arguments. (#1644) If you rely on file globbing in these methods or elsewhere, please open an issue on the BEAKER project.
+- Change `reboot` method to use `who -b` for uptime detection (#1643)
+
+### Fixed
+
+- Use Base64 UTF-16LE encoding for commands (#1626)
+- Fix `tmpdir` method for Powershell on Windows (#1645)
+
+# [4.22.1](https://github.com/puppetlabs/beaker/compare/4.22.0...4.22.1)
+
+### Fixed
+
+- Removed single quotes around paths for file operation commands on `Host` https://github.com/puppetlabs/beaker/pull/1642
 
 # [4.22.0](https://github.com/puppetlabs/beaker/compare/4.21.0...4.22.0) - 2020-05-08
 

data/beaker.gemspec

@@ -44,7 +44,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'rb-readline', '~> 0.5.3'
 
   s.add_runtime_dependency 'hocon', '~> 1.0'
-  s.add_runtime_dependency 'net-ssh', '~> 5.0'
+  s.add_runtime_dependency 'net-ssh', '>= 5.0'
   s.add_runtime_dependency 'net-scp', '~> 1.2'
   s.add_runtime_dependency 'inifile', '~> 3.0'
 

data/lib/beaker/dsl/helpers/host_helpers.rb

@@ -550,7 +550,6 @@ module Beaker
           file_contents = nil
 
           split_path = win_ads_path(file_path)
-
           if file_exists_on(host, split_path[:path])
             if host['platform'] =~ /windows/
               file_path.gsub!('/', '\\')

data/lib/beaker/dsl/helpers/web_helpers.rb

@@ -14,10 +14,11 @@ module Beaker
 
         #Determine is a given URL is accessible
         #@param [String] link The URL to examine
-        #@return [Boolean] true if the URL has a '200' HTTP response code, false otherwise
+        #@param [Integer] limit redirect limit, will follow redirects that many times
+        #@return [Boolean] true if the ultimate URL after following redirects (301&302) has a '200' HTTP response code, false otherwise
         #@example
         #  extension = link_exists?("#{URL}.tar.gz") ? ".tar.gz" : ".tar"
-        def link_exists?(link)
+        def link_exists?(link, limit=10)
           begin
             require "net/http"
             require "net/https"
@@ -26,8 +27,12 @@ module Beaker
             http = Net::HTTP.new(url.host, url.port)
             http.use_ssl = (url.scheme == 'https')
             http.verify_mode = (OpenSSL::SSL::VERIFY_NONE)
-            http.start do |http|
-              return http.head(url.request_uri).code == "200"
+            response = http.start { |http| http.head(url.request_uri) }
+            if (['301', '302'].include? response.code) && limit > 0
+              logger.debug("#{__method__} following #{response.code} to #{response['location']}")
+              link_exists?(response['location'], limit - 1)
+            else
+              response.code == "200"
             end
           rescue
             return false

data/lib/beaker/dsl/wrappers.rb

@@ -75,18 +75,14 @@ module Beaker
         Command.new("powershell.exe", ps_args)
       end
 
-      # Convert the provided command string to Base64
+      # Convert the provided command string to Base64 encoded UTF-16LE command
       # @param [String] cmd The command to convert to Base64
       # @return [String] The converted string
       # @api private
       def encode_command(cmd)
-        cmd = cmd.chars.to_a.join("\x00").chomp
-        cmd << "\x00" unless cmd[-1].eql? "\x00"
         # use strict_encode because linefeeds are not correctly handled in our model
-        cmd = Base64.strict_encode64(cmd).chomp
-        cmd
+        Base64.strict_encode64(cmd.encode(Encoding::UTF_16LE)).chomp
       end
-
     end
   end
 end

data/lib/beaker/host/pswindows/exec.rb

@@ -104,9 +104,9 @@ module PSWindows::Exec
   # @param [String] dir The directory structure to create on the host
   # @return [Boolean] True, if directory construction succeeded, otherwise False
   def mkdir_p dir
-    windows_dirstring = dir.gsub('/','\\')
-    cmd = "if not exist #{windows_dirstring} (md #{windows_dirstring})"
-    result = exec(Beaker::Command.new(cmd), :acceptable_exit_codes => [0, 1])
+    normalized_path = dir.gsub('/','\\')
+    result = exec(powershell("New-Item -Path '#{normalized_path}' -ItemType 'directory'"),
+                  :acceptable_exit_codes => [0, 1])
     result.exit_code == 0
   end
 
@@ -237,4 +237,19 @@ module PSWindows::Exec
     end
   end
 
+  #First path it finds for the command executable
+  #@param [String] command The command executable to search for
+  #
+  # @return [String] Path to the searched executable or empty string if not found
+  #
+  #@example
+  #  host.which('ruby')
+  def which(command)
+    where_command = "cmd /C \"where #{command}\""
+
+    result = execute(where_command, :accept_all_exit_codes => true)
+    return '' if result.empty?
+
+    result
+  end
 end

data/lib/beaker/host/pswindows/file.rb

@@ -7,16 +7,25 @@ module PSWindows::File
   end
 
   def tmpdir(name = '')
-    result = exec(powershell('[System.IO.Path]::GetTempPath()'))
-    result.stdout.chomp()
+    tmp_path = exec(powershell('[System.IO.Path]::GetTempPath()')).stdout.chomp()
+
+    if name == ''
+      name = exec(powershell('[System.IO.Path]::GetRandomFileName()')).stdout.chomp()
+    end
+    exec(powershell("New-Item -Path '#{tmp_path}' -Force -Name '#{name}' -ItemType 'directory'"))
+    File.join(tmp_path, name)
   end
 
   def path_split(paths)
     paths.split(';')
   end
 
+  def cat(path)
+    exec(powershell("type #{path}")).stdout
+  end
+
   def file_exist?(path)
-    result = exec(Beaker::Command.new("if exist #{path} echo true"), :acceptable_exit_codes => [0, 1])
-    result.stdout =~ /true/
+    result = exec(Beaker::Command.new("if exist #{path} echo true"), accept_all_exit_codes: true)
+    result.stdout.strip == 'true'
   end
 end

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

@@ -12,20 +12,23 @@ module Unix::Exec
   #
   # Will throw an exception RebootFailure if it fails
   def reboot(wait_time=10, max_connection_tries=9, uptime_retries=18)
+    require 'time'
+
     begin
-      original_uptime = exec(Beaker::Command.new("uptime"))
-      original_uptime_str = parse_uptime original_uptime.stdout
-      original_uptime_int = uptime_int original_uptime_str
+      original_boot_time_str = exec(Beaker::Command.new('who -b'), {:max_connection_tries => max_connection_tries, :silent => true}).stdout
+      original_boot_time_line = original_boot_time_str.lines.grep(/boot/).first
 
-      if self['platform'] =~ /solaris/
-        exec(Beaker::Command.new("reboot"), :expect_connection_failure => true)
-      else
-        exec(Beaker::Command.new("/sbin/shutdown -r now"), :expect_connection_failure => true)
-      end
+      raise Beaker::Host::RebootFailure, "Could not find system boot time using 'who -b': #{original_boot_time_str}" unless original_boot_time_line
+
+      original_boot_time = Time.parse(original_boot_time_line)
+
+      exec(Beaker::Command.new('/bin/systemctl reboot -i || reboot || /sbin/shutdown -r now'), :expect_connection_failure => true)
     rescue Beaker::Host::CommandFailure => e
       raise Beaker::Host::RebootFailure, "Command failed when attempting to reboot: #{e.message}"
     rescue RuntimeError => e
       raise Beaker::Host::RebootFailure, "Unexpected exception in reboot: #{e.message}"
+    rescue ArgumentError => e
+      raise Beaker::Host::RebootFailure, "Unable to parse time: #{e.message}"
     end
 
     attempts = 0
@@ -34,18 +37,19 @@ module Unix::Exec
       @logger.debug("Waiting #{wait_time} for host to shut down.")
       sleep wait_time
 
-      #use uptime to check if the host has rebooted
-      current_uptime_exec = exec(Beaker::Command.new("uptime"), {:max_connection_tries => max_connection_tries, :silent => true})
-      current_uptime = current_uptime_exec.stdout
-      current_uptime_str = parse_uptime current_uptime
-      current_uptime_int = uptime_int current_uptime_str
-      unless original_uptime_int > current_uptime_int
-        raise Beaker::Host::RebootFailure, "Uptime did not reset. Reboot appears to have failed."
+      current_boot_time_str = exec(Beaker::Command.new('who -b'), {:max_connection_tries => max_connection_tries, :silent => true}).stdout
+      current_boot_time = Time.parse(current_boot_time_str.lines.grep(/boot/).first)
+
+      @logger.debug("Original Boot Time: #{original_boot_time}")
+      @logger.debug("Current Boot Time: #{current_boot_time}")
+
+      unless current_boot_time > original_boot_time
+        raise Beaker::Host::RebootFailure, "Boot time did not reset. Reboot appears to have failed."
       end
     rescue Beaker::Host::RebootFailure => e
       attempts += 1
       if attempts < uptime_retries
-        @logger.debug("Uptime did not reset. Will retry #{uptime_retries - attempts} more times.")
+        @logger.debug("Boot time did not reset. Will retry #{uptime_retries - attempts} more times.")
         retry
       else
         raise
@@ -54,45 +58,11 @@ module Unix::Exec
       raise Beaker::Host::RebootFailure, "Command failed when attempting to reboot: #{e.message}"
     rescue RuntimeError => e
       raise Beaker::Host::RebootFailure, "Unexpected exception in reboot: #{e.message}"
+    rescue ArgumentError => e
+      raise Beaker::Host::RebootFailure, "Unable to parse time: #{e.message}"
     end
   end
 
-  def uptime_int(uptime_str)
-    time_array = uptime_str.split(", ")
-    accumulated_mins = 0
-    time_array.each do |time_segment|
-      value, unit = time_segment.split
-      if unit.nil?
-        # 20:47 case: hours & mins
-        hours, mins = value.split(":")
-        accumulated_mins += (hours.to_i * 60 + mins.to_i)
-      elsif unit =~ /day(s)?/
-        accumulated_mins += (value.to_i * 1440) # 60 * 24 = 1440
-      elsif unit =~ /min(s)?/
-        accumulated_mins += value.to_i
-      else
-        raise ArgumentError, "can't parse uptime segment: #{time_segment}"
-      end
-    end
-
-    accumulated_mins
-  end
-
-  def parse_uptime(uptime)
-    # get String from up to users
-    # eg 19:52  up 14 mins, 2 users, load averages: 2.95 4.19 4.31
-    # 8:03 up 52 days, 20:47, 3 users, load averages: 1.36 1.42 1.40
-    # 22:19 up 54 days, 1 min, 4 users, load averages: 2.08 2.06 2.27
-    regexp = /.*up (.*)[[:space:]]+[[:digit:]]+ user.*/
-    result = uptime.match regexp
-    if self['platform'] =~ /solaris-/ && result[1].empty?
-      return "0 min"
-    end
-    raise "Couldn't parse uptime: #{uptime}" if result.nil?
-
-    result[1].strip.chomp(",")
-  end
-
   def echo(msg, abs=true)
     (abs ? '/bin/echo' : 'echo') + " #{msg}"
   end
@@ -127,7 +97,7 @@ module Unix::Exec
   # @param [String] dir The directory structure to create on the host
   # @return [Boolean] True, if directory construction succeeded, otherwise False
   def mkdir_p dir
-    cmd = "mkdir -p '#{dir}'"
+    cmd = "mkdir -p #{dir}"
     result = exec(Beaker::Command.new(cmd), :acceptable_exit_codes => [0, 1])
     result.exit_code == 0
   end
@@ -135,7 +105,7 @@ module Unix::Exec
   # Recursively remove the path provided
   # @param [String] path The path to remove
   def rm_rf path
-    execute("rm -rf '#{path}'")
+    execute("rm -rf #{path}")
   end
 
   # Move the origin to destination. The destination is removed prior to moving.
@@ -144,7 +114,7 @@ module Unix::Exec
   # @param [Boolean] rm Remove the destination prior to move
   def mv orig, dest, rm=true
     rm_rf dest unless !rm
-    execute("mv '#{orig}' '#{dest}'")
+    execute("mv #{orig} #{dest}")
   end
 
   # Attempt to ping the provided target hostname
@@ -429,4 +399,19 @@ module Unix::Exec
     true
   end
 
+  #First path it finds for the command executable
+  #@param [String] command The command executable to search for
+  #
+  # @return [String] Path to the searched executable or empty string if not found
+  #
+  #@example
+  #  host.which('ruby')
+  def which(command)
+    which_command = "which #{command}"
+
+    result = execute(which_command, :accept_all_exit_codes => true)
+    return '' if result.empty?
+
+    result
+  end
 end

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

@@ -58,6 +58,10 @@ module Unix::File
     execute("ls -ld #{path}")
   end
 
+  def cat(path)
+    execute("cat #{path}")
+  end
+
   # Handles any changes needed in a path for SCP
   #
   # @param [String] path File path to SCP to

data/lib/beaker/host/windows/exec.rb

@@ -119,6 +119,25 @@ module Windows::Exec
     false
   end
 
+  # Create the provided directory structure on the host
+  # @param [String] dir The directory structure to create on the host
+  # @return [Boolean] True, if directory construction succeeded, otherwise False
+  def mkdir_p dir
+    cmd = "mkdir -p \"#{dir}\""
+    result = exec(Beaker::Command.new(cmd), :acceptable_exit_codes => [0, 1])
+    result.exit_code == 0
+  end
+
+  # Move the origin to destination. The destination is removed prior to moving.
+  # @param [String] orig The origin path
+  # @param [String] dest the destination path
+  # @param [Boolean] rm Remove the destination prior to move
+  def mv orig, dest, rm=true
+    rm_rf dest unless !rm
+    execute("mv \"#{orig}\" \"#{dest}\"")
+  end
+
+
   # Determine if cygwin is actually installed on the SUT. Differs from
   # is_cygwin?, which is just a type check for a Windows::Host.
   #

data/lib/beaker/ssh_connection.rb

@@ -68,6 +68,11 @@ module Beaker
       max_connection_tries = options[:max_connection_tries] || 11
       begin
          @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
+
+         if ssh_opts.include?(:strict_host_key_checking) && (Net::SSH::Version::CURRENT.major > 5)
+           ssh_opts[:paranoid] = ssh_opts.delete(:strict_host_key_checking)
+         end
+
          Net::SSH.start(host, user, ssh_opts)
       rescue *RETRYABLE_EXCEPTIONS => e
         if try <= max_connection_tries

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '4.22.0'
+    STRING = '4.24.0'
   end
 end

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

@@ -99,5 +99,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

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+module Beaker
+  describe PSWindows::File do
+    class PSWindowsFileTest
+      include PSWindows::File
+      include Beaker::DSL::Wrappers
+
+      def initialize(hash, logger)
+        @hash = hash
+        @logger = logger
+      end
+
+      def [](k)
+        @hash[k]
+      end
+
+      def to_s
+        "me"
+      end
+    end
+
+    let (:opts)     { @opts || {} }
+    let (:logger)   { double( 'logger' ).as_null_object }
+    let (:instance) { PSWindowsFileTest.new(opts, logger) }
+
+    describe '#cat' do
+      let(:path) { '/path/to/cat' }
+      let(:content) { 'file content' }
+      it 'reads output for file' do
+        expect(instance).to receive(:exec).and_return(double(stdout: content))
+        expect(Beaker::Command).to receive(:new).with('powershell.exe', array_including("-Command type #{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
+
+    describe '#tmpdir' do
+      let(:tmp_path) { 'C:\\tmpdir\\' }
+      let(:fake_command) { Beaker::Command.new('command1') }
+
+      before do
+        allow(instance).to receive(:execute).with(anything)
+      end
+
+      context 'with dirname sent' do
+        let(:name) { 'my_dir' }
+        it 'returns the path to my_dir' do
+          expect(Beaker::Command).to receive(:new).
+            with('powershell.exe', array_including('-Command [System.IO.Path]::GetTempPath()')).
+            and_return(fake_command)
+          expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(double(stdout: tmp_path))
+
+          expect(Beaker::Command).to receive(:new).
+            with('powershell.exe', array_including("-Command New-Item -Path '#{tmp_path}' -Force -Name '#{name}' -ItemType 'directory'")).
+            and_return(fake_command)
+          expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(true)
+
+          expect(instance.tmpdir(name)).to eq(File.join(tmp_path, name))
+        end
+      end
+
+      context 'without dirname sent' do
+        let(:name) { '' }
+        let(:random_dir) { 'dirname' }
+
+        it 'returns the path to random name dir' do
+          expect(Beaker::Command).to receive(:new).
+            with('powershell.exe', array_including('-Command [System.IO.Path]::GetTempPath()')).
+            and_return(fake_command)
+          expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(double(stdout: tmp_path))
+
+          expect(Beaker::Command).to receive(:new).
+            with('powershell.exe', array_including('-Command [System.IO.Path]::GetRandomFileName()')).
+            and_return(fake_command)
+          expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(double(stdout: random_dir))
+
+          expect(Beaker::Command).to receive(:new).
+            with('powershell.exe', array_including("-Command New-Item -Path '#{tmp_path}' -Force -Name '#{random_dir}' -ItemType 'directory'")).
+            and_return(fake_command)
+          expect(instance).to receive(:exec).with(instance_of(Beaker::Command)).and_return(true)
+
+          expect(instance.tmpdir).to eq(File.join(tmp_path, random_dir))
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@ module Beaker
 
       it "deletes" do
         path = '/path/to/delete'
-        expect( instance ).to receive(:execute).with("rm -rf '#{path}'").and_return(0)
+        expect( instance ).to receive(:execute).with("rm -rf #{path}").and_return(0)
         expect( instance.rm_rf(path) ).to be === 0
       end
     end
@@ -39,14 +39,14 @@ module Beaker
       let(:destination) { '/destination/path/of/content' }
 
       it 'rm first' do
-        expect( instance ).to receive(:execute).with("rm -rf '#{destination}'").and_return(0)
-        expect( instance ).to receive(:execute).with("mv '#{origin}' '#{destination}'").and_return(0)
+        expect( instance ).to receive(:execute).with("rm -rf #{destination}").and_return(0)
+        expect( instance ).to receive(:execute).with("mv #{origin} #{destination}").and_return(0)
         expect( instance.mv(origin, destination) ).to be === 0
 
       end
 
       it 'does not rm' do
-         expect( instance ).to receive(:execute).with("mv '#{origin}' '#{destination}'").and_return(0)
+         expect( instance ).to receive(:execute).with("mv #{origin} #{destination}").and_return(0)
          expect( instance.mv(origin, destination, false) ).to be === 0
       end
     end
@@ -171,94 +171,135 @@ module Beaker
     describe '#reboot' do
       # no-op response
       let (:response) { double( 'response' ) }
-      let (:uptime_initial_response) { double( 'response' ) }
-      let (:uptime_initial_stdout) { '19:52  up 14 mins, 2 users, load averages: 2.95 4.19 4.31' }
+      let (:boot_time_initial_response) { double( 'response' ) }
 
-      let (:uptime_success_response) { double( 'response' ) }
-      let (:uptime_success_stdout) { '19:52  up 0 mins, 2 users, load averages: 2.95 4.19 4.31' }
+      let (:boot_time_success_response) { double( 'response' ) }
       let (:sleep_time) { 10 }
 
       before :each do
-        # stubs enough to survive the first uptime call & output parsing
+        # 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("uptime").and_return(:uptime_command_stub)
+        allow(Beaker::Command).to receive(:new).with('who -b').and_return(:boot_time_command_stub)
 
-        # mock initial uptime call
-        allow(instance).to receive( :exec ).with(:uptime_command_stub).and_return(uptime_initial_response).once
-        allow(uptime_initial_response).to receive(:stdout).and_return(uptime_initial_stdout)
-
-        allow(uptime_success_response).to receive(:stdout).and_return(uptime_success_stdout)
+        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)
 
         allow(instance).to receive(:sleep)
 
-        allow(Beaker::Command).to receive(:new).with("/sbin/shutdown -r now").and_return(:shutdown_command_stub)
+        allow(Beaker::Command).to receive(:new).with("/bin/systemctl reboot -i || reboot || /sbin/shutdown -r now").and_return(:shutdown_command_stub)
       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
-        expect{ instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Command failed when attempting to reboot: .*/)
-      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 '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::RebootFailure, /Unexpected exception in reboot: .*/)
-      end
+        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 'raises RebootFailure if new uptime is never less than old uptime' 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
-        # allow the second uptime 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(:uptime_command_stub, anything).and_return(uptime_initial_response).exactly(18).times
+          expect(instance.reboot).to be(nil)
+        end
 
-        expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Uptime did not reset/)
-      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 'raises RebootFailure if new uptime is never less than old uptime when 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
-        # allow the second uptime and the hash arguments in exec, repeated 10 times by default
-        expect(instance).to receive( :exec ).with(:uptime_command_stub, anything).and_return(uptime_initial_response).exactly(10).times
+          expect(instance.reboot(10)).to be(nil)
+        end
 
-        expect { instance.reboot(wait_time=sleep_time, max_connection_tries=9, uptime_retries=10) }.to raise_error(Beaker::Host::RebootFailure, /Uptime did not reset/)
-      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
+
+          expect(instance.reboot(sleep_time, 20)).to be(nil)
+        end
+
+        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
+
+          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
+
+            expect{ instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Command failed when attempting to reboot: .*/)
+          end
+
+          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::RebootFailure, /Unexpected exception in reboot: .*/)
+          end
 
-      it 'passes if new uptime is less than old uptime' 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
-        # allow the second uptime and the hash arguments in exec
-        expect(instance).to receive( :exec ).with(:uptime_command_stub, anything).and_return(uptime_success_response).once
+          context 'incorrect time string' do
+            context 'original time' do
+              let (:boot_time_initial_stdout) { 'boot bad' }
 
-        expect(instance.reboot).to be(nil)
+              it 'raises a reboot failure' do
+                expect(instance).not_to receive(:sleep)
+
+                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
+              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).once
+
+                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
+              end
+            end
+          end
+        end
       end
 
-      context 'with wait_time_parameter' do
-        it 'passes if new uptime is less than old uptime' do
-          expect(instance).to receive(:sleep).with(10)
+      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' }
+
+        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
-          # allow the second uptime and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:uptime_command_stub, anything).and_return(uptime_success_response).once
 
-          expect(instance.reboot(10)).to be(nil)
+          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.reboot }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
         end
-      end
 
-      context 'with max_connection_tries parameter' do
-        it 'passes if new uptime is less than old uptime' do
+        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
-          # allow the second uptime and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:uptime_command_stub, hash_including(:max_connection_tries => 20)).and_return(uptime_success_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
 
-          expect(instance.reboot(sleep_time, 20)).to be(nil)
+          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
 
     describe '#enable_remote_rsyslog' do
@@ -272,40 +313,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"
-      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"
+    describe '#which' do
+      before do
+        allow(instance).to receive(:execute)
+                               .with(where_command, :accept_all_exit_codes => true).and_return(result)
       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

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

@@ -196,6 +196,14 @@ module Beaker
       end
     end
 
+    describe '#cat' do
+      let (:path) { '/path/to/cat/on' }
+      it 'calls cat for path' do
+        expect( instance ).to receive( :execute ).with( "cat #{path}" ).and_return( 0 )
+        expect( instance.cat( path ) ).to be === 0
+      end
+    end
+
     describe '#chmod' do
       context 'not recursive' do
         it 'calls execute with chmod' do

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

@@ -3,6 +3,7 @@ require 'spec_helper'
 module Beaker
   describe Windows::Exec do
     class WindowsExecTest
+      include Unix::Exec
       include Windows::Exec
 
       def initialize(hash, logger)
@@ -78,5 +79,22 @@ module Beaker
         expect(instance.cygwin_installed?).to eq(false)
       end
     end
+
+    context 'mv' do
+      let(:origin)      { '/origin/path/of/content' }
+      let(:destination) { '/destination/path/of/content' }
+
+      it 'rm first' do
+        expect( instance ).to receive(:execute).with("rm -rf #{destination}").and_return(0)
+        expect( instance ).to receive(:execute).with("mv \"#{origin}\" \"#{destination}\"").and_return(0)
+        expect( instance.mv(origin, destination) ).to be === 0
+
+      end
+
+      it 'does not rm' do
+         expect( instance ).to receive(:execute).with("mv \"#{origin}\" \"#{destination}\"").and_return(0)
+         expect( instance.mv(origin, destination, false) ).to be === 0
+      end
+    end
   end
 end

data/spec/beaker/host_spec.rb

@@ -325,7 +325,7 @@ module Beaker
         allow( result ).to receive( :exit_code ).and_return( 0 )
         allow( host ).to receive( :exec ).and_return( result )
 
-        expect( Beaker::Command ).to receive(:new).with("mkdir -p 'test/test/test'")
+        expect( Beaker::Command ).to receive(:new).with("mkdir -p \"test/test/test\"")
         expect( host.mkdir_p('test/test/test') ).to be == true
 
       end
@@ -337,7 +337,7 @@ module Beaker
         allow( result ).to receive( :exit_code ).and_return( 0 )
         allow( host ).to receive( :exec ).and_return( result )
 
-        expect( Beaker::Command ).to receive(:new).with("mkdir -p 'test/test/test'")
+        expect( Beaker::Command ).to receive(:new).with("mkdir -p \"test/test/test\"")
         expect( host.mkdir_p('test/test/test') ).to be == true
 
       end
@@ -349,7 +349,13 @@ module Beaker
         allow( result ).to receive( :exit_code ).and_return( 0 )
         allow( host ).to receive( :exec ).and_return( result )
 
-        expect( Beaker::Command ).to receive(:new).with("if not exist test\\test\\test (md test\\test\\test)")
+        expect( Beaker::Command ).to receive(:new).
+          with("powershell.exe", ["-ExecutionPolicy Bypass",
+                                  "-InputFormat None",
+                                  "-NoLogo",
+                                  "-NoProfile",
+                                  "-NonInteractive",
+                                  "-Command New-Item -Path 'test\\test\\test' -ItemType 'directory'"])
         expect( host.mkdir_p('test/test/test') ).to be == true
 
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker
 version: !ruby/object:Gem::Version
-  version: 4.22.0
+  version: 4.24.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-08 00:00:00.000000000 Z
+date: 2020-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -216,14 +216,14 @@ dependencies:
   name: net-ssh
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
@@ -630,6 +630,7 @@ files:
 - spec/beaker/host/mac/user_spec.rb
 - spec/beaker/host/mac_spec.rb
 - spec/beaker/host/pswindows/exec_spec.rb
+- spec/beaker/host/pswindows/file_spec.rb
 - spec/beaker/host/pswindows/user_spec.rb
 - spec/beaker/host/pswindows_spec.rb
 - spec/beaker/host/unix/exec_spec.rb