beaker 4.23.1 → 4.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 442731199e19c2bfbd64dbc64851c80155659e8e7deee3e6512fe05006056efb
-  data.tar.gz: 51c93bf9df5a4ef96c3739dbbae19d41ca70e91f03a250a4e6c5418294d7cfc9
+  metadata.gz: b7bc325aade2e41145790de7c1c5d8c3f07b054dc22999762cbbe812f81deeca
+  data.tar.gz: 403bc79d97df6b8b30d59a5caa8ef26434e1adfc6420025cc15d3267c149aaef
 SHA512:
-  metadata.gz: 838c910a425573e64ae111686c1a3b1da59c2cfc4d485b177af8374d103a1879aab0a41fd0f9074a438c0adda41d4acbd3adc55017d7e49a52df79ffc1c91403
-  data.tar.gz: 6869be1711abcdeaf5166213ec3ba082e5e1210576c0fab3d777cb0a902793465acd44bd4e36a8ae6e7aa2ebb2be5cf6f4d0f096c65c12c0ac765163e891741c
+  metadata.gz: fe7a3e52bc3db292ae174f97f2c93b2455e032693956931b60e6bc5cc1c0caf84be93f92d877d9bcdb7698f77e3367c08e0781e2e858b5c9a5d335d99d6b059f
+  data.tar.gz: 6616a6a1bb3399a30defc9536b64b67d7f742d67dddf09f8dad70604a0df9b9c4460c414080e70f42001495bdb47e1dcab8a9354210fb67348453ea065933707

data/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "13:00"
+  open-pull-requests-limit: 10

data/.travis.yml

@@ -1,5 +1,5 @@
 before_install:
-  - gem update --system 2.2.1
+  - gem update
   - gem --version
 language: ruby
 script: "bundle exec rake travis"
@@ -7,6 +7,4 @@ notifications:
   email: false
 rvm:
   - 2.6
-  - 2.0.0
-  - 1.9.3
-  - 1.8.7-p374
+  - 2.4

data/CHANGELOG.md

@@ -20,7 +20,55 @@ 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.23.1...master)
+# [Unreleased](https://github.com/puppetlabs/beaker/compare/4.27.0...master)
+
+# [4.27.0](https://github.com/puppetlabs/beaker/compare/4.26.0...4.27.0) - 07-24-2020
+
+### Changed
+
+- Updated dependency versions and minimum Ruby version in gemspec to Ruby 2.4, which is the minimum
+  version Beaker will run with.
+- Added Travis unit testing and disabled Jenkins integrations in preparation for transferring the
+  repo to Vox Pupuli
+
+
+# [4.26.0](https://github.com/puppetlabs/beaker/compare/4.25.0...4.26.0)
+
+### Changed
+
+- Fixed deprecated SSH option handling for `verify_ssh_key` being passed into Net::SSH. #1655
+
+### Removed
+
+- Removed deprecated use of `paranoid` flag with Net::SSH. #1655
+
+# [4.25.0](https://github.com/puppetlabs/beaker/compare/4.24.0...4.25.0)
+
+### Added
+
+- Execution of Beaker directly through ruby on localhost #1637 ([#1637](https://github.com/puppetlabs/beaker/pull/1637))
+
+### Fixed
+
+- Reliability improvements to the `Host#reboot` method ([#1656](https://github.com/puppetlabs/beaker/pull/1656)) ([#1659](https://github.com/puppetlabs/beaker/pull/1659))
+
+# [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)
 

data/CODEOWNERS

@@ -1,2 +0,0 @@
-* @puppetlabs/beaker
-* @puppetlabs/dio

data/Rakefile

@@ -26,10 +26,7 @@ task :history do
   Rake::Task['history:gen'].invoke
 end
 
-task :travis do
-  Rake::Task['yard'].invoke if !Beaker::Shared::Semvar.version_is_less(RUBY_VERSION, '2.0.0')
-  Rake::Task['spec'].invoke
-end
+task travis: [:yard, :test]
 
 module HarnessOptions
   defaults = {

data/beaker.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.required_ruby_version = Gem::Requirement.new('>= 2.1.8')
+  s.required_ruby_version = Gem::Requirement.new('>= 2.4')
 
   # Testing dependencies
   s.add_development_dependency 'rspec', '~> 3.0'
@@ -39,7 +39,7 @@ Gem::Specification.new do |s|
   # Run time dependencies
   s.add_runtime_dependency 'minitest', '~> 5.4'
   s.add_runtime_dependency 'minitar', '~> 0.6'
-  s.add_runtime_dependency 'pry-byebug', '~> 3.6'
+  s.add_runtime_dependency 'pry-byebug', '~> 3.9'
   # pry-byebug can have issues with native readline libs so add rb-readline
   s.add_runtime_dependency 'rb-readline', '~> 0.5.3'
 

data/lib/beaker/host.rb

@@ -6,7 +6,7 @@ require 'rsync'
 require 'beaker/dsl/helpers'
 require 'beaker/dsl/patterns'
 
-[ 'command', 'ssh_connection'].each do |lib|
+[ 'command', 'ssh_connection', 'local_connection' ].each do |lib|
   require "beaker/#{lib}"
 end
 
@@ -294,6 +294,11 @@ module Beaker
 
     def connection
       # create new connection object if necessary
+      if self['hypervisor'] == 'none' && @name == 'localhost'
+        @connection ||= LocalConnection.connect( { :ssh_env_file => self['ssh_env_file'], :logger => @logger })
+        return @connection
+      end
+
       @connection ||= SshConnection.connect( { :ip => self['ip'], :vmhostname => self['vmhostname'], :hostname => @name },
                                              self['user'],
                                              self['ssh'], { :logger => @logger, :ssh_connection_preference => self[:ssh_connection_preference]} )

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

@@ -21,11 +21,11 @@ module PSWindows::File
   end
 
   def cat(path)
-    exec(powershell("type #{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

@@ -14,15 +14,27 @@ module Unix::Exec
   def reboot(wait_time=10, max_connection_tries=9, uptime_retries=18)
     require 'time'
 
+    attempts = 0
+
+    original_boot_time_str = nil
+    original_boot_time_line = nil
     begin
       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
 
-      raise Beaker::Host::RebootFailure, "Could not find system boot time using 'who -b': #{original_boot_time_str}" unless original_boot_time_line
+      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::RebootFailure => e
+      attempts += 1
+      if attempts < uptime_retries
+        @logger.debug("Could not get initial boot time. Will retry #{uptime_retries - attempts} more times.")
+        retry
+      else
+        raise
+      end
     rescue Beaker::Host::CommandFailure => e
       raise Beaker::Host::RebootFailure, "Command failed when attempting to reboot: #{e.message}"
     rescue RuntimeError => e
@@ -38,7 +50,11 @@ module Unix::Exec
       sleep wait_time
 
       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)
+      current_boot_time_line = current_boot_time_str.lines.grep(/boot/).first
+
+      raise Beaker::Host::RebootFailure, "Could not find system boot time using 'who -b': '#{current_boot_time_str}'" unless current_boot_time_line
+
+      current_boot_time = Time.parse(current_boot_time_line)
 
       @logger.debug("Original Boot Time: #{original_boot_time}")
       @logger.debug("Current Boot Time: #{current_boot_time}")
@@ -63,42 +79,6 @@ module Unix::Exec
     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
@@ -435,4 +415,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/local_connection.rb

@@ -0,0 +1,86 @@
+require 'open3'
+
+module Beaker
+  class LocalConnection
+
+    attr_accessor :logger, :hostname, :ip
+
+    def initialize options = {}
+      @logger = options[:logger]
+      @ssh_env_file = File.expand_path(options[:ssh_env_file])
+      @hostname = 'localhost'
+      @ip = '127.0.0.1'
+      @options = options
+    end
+
+    def self.connect options = {}
+      connection = new options
+      connection.connect
+      connection
+    end
+
+    def connect options = {}
+      @logger.debug "Local connection, no connection to start"
+    end
+
+    def close
+      @logger.debug "Local connection, no connection to close"
+    end
+
+    def with_env(env)
+      backup = ENV.to_hash
+      ENV.replace(env)
+      yield
+    ensure
+      ENV.replace(backup)
+    end
+
+    def execute command, options = {}, stdout_callback = nil, stderr_callback = stdout_callback
+      result = Result.new(@hostname, command)
+      envs = {}
+      if File.readable?(@ssh_env_file)
+        File.foreach(@ssh_env_file) do |line|
+          key, value = line.split('=')
+          envs[key] = value
+        end
+      end
+
+      begin
+        clean_env = ENV.reject{ |k| k =~ /^BUNDLE|^RUBY|^GEM/ }
+
+        with_env(clean_env) do
+          std_out, std_err, status = Open3.capture3(envs, command)
+          result.stdout << std_out
+          result.stderr << std_err
+          result.exit_code = status.exitstatus
+        end
+      rescue => e
+        result.stderr << e.inspect
+        result.exit_code = 1
+      end
+
+      result.finalize!
+      @logger.last_result = result
+      result
+    end
+
+    def scp_to(source, target, _options = {})
+
+      result = Result.new(@hostname, [source, target])
+      begin
+        FileUtils.cp_r source, target
+      rescue Errno::ENOENT => e
+        @logger.warn "#{e.class} error in cp'ing. Forcing the connection to close, which should " \
+                        "raise an error."
+      end
+
+      result.stdout << "  CP'ed file #{source} to #{target}"
+      result.exit_code = 0
+      result
+    end
+
+    def scp_from(source, target, options = {})
+      scp_to(target, source, options)
+    end
+  end
+end

data/lib/beaker/ssh_connection.rb

@@ -68,6 +68,16 @@ module Beaker
       max_connection_tries = options[:max_connection_tries] || 11
       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)
+           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)
       rescue *RETRYABLE_EXCEPTIONS => e
         if try <= max_connection_tries

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '4.23.1'
+    STRING = '4.27.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

@@ -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

@@ -313,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"
+    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 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"
-      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_spec.rb

@@ -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

data/spec/beaker/localhost_connection_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'net/ssh'
+
+module Beaker
+  describe LocalConnection do
+    let( :options )   { { :logger => double('logger').as_null_object, :ssh_env_file => '/path/to/ssh/file'} }
+    subject(:connection) { LocalConnection.new(options) }
+
+    before :each do
+      allow( subject ).to receive(:sleep)
+    end
+
+    describe '#self.connect' do
+      it 'loggs message' do
+        expect(options[:logger]).to receive(:debug).with('Local connection, no connection to start')
+        connection_constructor = LocalConnection.connect(options)
+        expect( connection_constructor ).to be_a_kind_of LocalConnection
+      end
+    end
+
+    describe '#close' do
+      it 'logs message' do
+        expect(options[:logger]).to receive(:debug).with('Local connection, no connection to close')
+        connection.close
+      end
+    end
+
+    describe '#with_env' do
+      it 'sets envs temporarily' do
+        connection.connect
+        connection.with_env({'my_env' => 'my_env_value'}) do
+          expect(ENV.to_hash).to include({'my_env' => 'my_env_value'})
+        end
+        expect(ENV.to_hash).not_to include({'my_env' => 'my_env_value'})
+      end
+    end
+
+    describe '#execute' do
+      it 'calls open3' do
+        expect( Open3 ).to receive( :capture3 ).with({}, 'my_command')
+        connection.connect
+        expect(connection.execute('my_command')).to be_a_kind_of Result
+      end
+
+      it 'sets stdout, stderr and exitcode' do
+        allow(Open3).to receive(:capture3).and_return(['stdout', 'stderr', double({exitstatus: 0})])
+        connection.connect
+        result = connection.execute('my_command')
+        expect(result.exit_code).to eq(0)
+        expect(result.stdout).to eq('stdout')
+        expect(result.stderr).to eq('stderr')
+      end
+
+      it 'sets logger last_result' do
+        allow(Open3).to receive(:capture3).and_return(['stdout', 'stderr', double({exitstatus: 0})])
+        expect(options[:logger]).to receive(:last_result=).with(an_instance_of(Result))
+        connection.connect
+        connection.execute('my_command')
+      end
+
+      it 'sets exitcode to 1, when Open3 raises exeception' do
+        allow(Open3).to receive(:capture3).and_raise Errno::ENOENT
+        connection.connect
+        result = connection.execute('my_failing_command')
+        expect(result.exit_code).to eq(1)
+      end
+    end
+
+    describe '#scp_to' do
+      let(:source) { '/source/path' }
+      let(:dest) { '/dest/path' }
+
+      it 'calls FileUtils.cp_r' do
+        connection.connect
+        expect(FileUtils).to receive(:cp_r).with(source, dest)
+        connection.scp_to(source, dest)
+      end
+
+      it 'returns and Result object' do
+        expect(FileUtils).to receive(:cp_r).and_return(true)
+        connection.connect
+        result = connection.scp_to(source, dest)
+        expect(result.exit_code).to eq(0)
+        expect(result.stdout).to eq("  CP'ed file #{source} to #{dest}")
+      end
+
+      it 'catches exception and logs warning message' do
+        allow(FileUtils).to receive(:cp_r).and_raise Errno::ENOENT
+        expect(options[:logger]).to receive(:warn).with("Errno::ENOENT error in cp'ing. Forcing the connection to close, which should raise an error.")
+        connection.connect
+        connection.scp_to(source, dest)
+      end
+    end
+
+    describe '#scp_from' do
+      let(:source) { '/source/path' }
+      let(:dest) { '/dest/path' }
+
+      it 'callse scp_to with reversed params' do
+        expect(connection).to receive(:scp_to).with(dest, source, {})
+        connection.connect
+        connection.scp_from(source, dest)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker
 version: !ruby/object:Gem::Version
-  version: 4.23.1
+  version: 4.27.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-20 00:00:00.000000000 Z
+date: 2020-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -176,14 +176,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '3.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rb-readline
   requirement: !ruby/object:Gem::Requirement
@@ -352,6 +352,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".gitignore"
 - ".rspec"
 - ".simplecov"
@@ -576,6 +577,7 @@ files:
 - lib/beaker/hypervisor.rb
 - lib/beaker/hypervisor/noop.rb
 - lib/beaker/junit.xsl
+- lib/beaker/local_connection.rb
 - lib/beaker/logger.rb
 - lib/beaker/logger_junit.rb
 - lib/beaker/network_manager.rb
@@ -646,6 +648,7 @@ files:
 - spec/beaker/host_prebuilt_steps_spec.rb
 - spec/beaker/host_spec.rb
 - spec/beaker/hypervisor/hypervisor_spec.rb
+- spec/beaker/localhost_connection_spec.rb
 - spec/beaker/logger_junit_spec.rb
 - spec/beaker/logger_spec.rb
 - spec/beaker/network_manager_spec.rb
@@ -692,14 +695,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.8
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Let's test Puppet!