cem_win_spec 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdb91d3bd9c4220238d0712938226a34f036c4313370f0ac70b818402d67051d
-  data.tar.gz: 6e1b4a03b910513b5d4e985f5643394834f0ff38e7af9c03ffebe24a179d1f61
+  metadata.gz: c59006dbfceccc0e0581630b0091722aa31a5644440bb906572c8429a654c37a
+  data.tar.gz: 91d3e8e17c961d90e90dd5895376418279062ace8ee3b3327d24a511b7287a98
 SHA512:
-  metadata.gz: d36cc7f04c91d80fd494caecbe1ee33b39a71d3cde95cf71f4381ba12c232f0f4ed02b91886a89a9e4d2253d1b8ca9bc58bb8348e69d8eda97c7e5d5da22399c
-  data.tar.gz: c3fc479c502495358843257577391242f7c7003abee9fcb73e7dfa2e456adcd9bbbd448b864b9df347096d519c6ca4ca9ce6c9a7be71582acca448710bb88807
+  metadata.gz: cddc71efc46c8a5a0872ee5670b6bdcff1b77904190e18e87f3fa728f2bdb8c533bef7382e8df918337b87811fc21ac04a4b0bd0f358774911a78279f9709968
+  data.tar.gz: d52050dd876973fadb74a801b198e88f56341ee125a96a6407594376d6155a3a02a7037576ec10f775346660a7d5fd34ee75e26966ef7011889c45ad968a9e02

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_win_spec (0.1.1)
+    cem_win_spec (0.1.3)
       parallel_tests (~> 3.4)
       puppet_forge (~> 4.1)
       tty-spinner (~> 0.9)
@@ -15,21 +15,22 @@ GEM
     builder (3.2.4)
     coderay (1.1.3)
     diff-lcs (1.5.0)
-    erubi (1.10.0)
-    faraday (2.3.0)
-      faraday-net_http (~> 2.0)
+    erubi (1.12.0)
+    faraday (2.7.5)
+      faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
     faraday-follow_redirects (0.3.0)
       faraday (>= 1, < 3)
-    faraday-net_http (2.0.3)
+    faraday-net_http (3.0.2)
     ffi (1.15.5)
     gssapi (1.3.1)
       ffi (>= 1.0.1)
-    gyoku (1.3.1)
+    gyoku (1.4.0)
       builder (>= 2.1.2)
+      rexml (~> 3.0)
     httpclient (2.8.3)
     little-plugger (1.1.4)
-    logging (2.3.0)
+    logging (2.3.1)
       little-plugger (~> 1.1)
       multi_json (~> 1.14)
     method_source (1.0.0)
@@ -81,7 +82,7 @@ GEM
     ruby2_keywords (0.0.5)
     rubyntlm (0.6.3)
     rubyzip (2.3.2)
-    semantic_puppet (1.0.4)
+    semantic_puppet (1.1.0)
     tty-cursor (0.7.1)
     tty-spinner (0.9.3)
       tty-cursor (~> 0.7)
@@ -103,6 +104,7 @@ GEM
 
 PLATFORMS
   x86_64-darwin-19
+  x86_64-darwin-20
 
 DEPENDENCIES
   cem_win_spec!

data/exe/cem-win-spec

@@ -3,6 +3,7 @@
 
 require 'optparse'
 require 'cem_win_spec'
+require 'cem_win_spec/version'
 
 # This is a wrapper script for the cem_win_spec gem. It is used to run the
 # cem_win_spec gem from the command line. It is installed as part of the gem
@@ -18,6 +19,26 @@ parser = OptionParser.new do |opts|
     exit 0
   end
 
+  opts.on('-p', '--puppet-version [VERSION]', 'Puppet version to test against') do |version|
+    unless %w[7 8].include?(version)
+      warn "Unknown Puppet version: #{version}"
+      warn 'Valid versions are: 7, 8'
+      puts opts
+      exit 1
+    end
+    options[:puppet_version] = version
+  end
+
+  opts.on('-r', '--ruby-version [VERSION]', 'Ruby version to test against') do |version|
+    unless %w[2 3].include?(version)
+      warn "Unknown Ruby version: #{version}"
+      warn 'Valid versions are: 2, 3'
+      puts opts
+      exit 1
+    end
+    options[:ruby_version] = version
+  end
+
   opts.on('-o', '--operation [OPERATION]', 'Operation to perform (spec, clean_fixture_cache)') do |operation|
     unless %w[spec clean_fixture_cache].include?(operation)
       warn "Unknown operation: #{operation}"

data/lib/cem_win_spec/iap_tunnel.rb

@@ -4,6 +4,8 @@ require 'io/console'
 require_relative 'logging'
 
 module CemWinSpec
+  class IapTunnelStartError < StandardError; end
+
   # This class is used to create a tunnel to a GCP instance
   class IapTunnel
     include CemWinSpec::Logging
@@ -23,7 +25,9 @@ module CemWinSpec
     end
 
     def running?
-      !@pid.nil?
+      !@pid.nil? && Process.getpgid(@pid)
+    rescue Errno::ESRCH
+      false
     end
 
     def with
@@ -41,7 +45,12 @@ module CemWinSpec
       logger.info 'Starting IAP tunnel...'
       logger.debug "Running command: #{tunnel_cmd}"
       @pid = spawn(tunnel_cmd)
-      sleep(5)
+      sleep(3) # Give the tunnel a few seconds to start
+      Process.getpgid(@pid) # Check if the process starts successfully
+      logger.info "IAP tunnel started on port #{port}"
+    rescue Errno::ESRCH
+      @pid = nil
+      raise IapTunnelStartError, "Failed to start IAP tunnel on port #{port}: #{$ERROR_INFO}"
     end
 
     # This method stops the IAP tunnel

data/lib/cem_win_spec/rspec_test_cmds.rb

@@ -6,24 +6,25 @@ module CemWinSpec
   class RspecTestCmds
     DEFAULT_PATTERN = 'spec/{classes,defines}/**/*_spec.rb'
 
-    def initialize(pattern: DEFAULT_PATTERN)
+    def initialize(use_bundler: true, pattern: DEFAULT_PATTERN)
+      @use_bundler = use_bundler
       @pattern = pattern
     end
 
     def cmd_standalone(*args)
-      "bundle exec rake 'cem:spec_standalone#{rake_args(nil, *args)}'"
+      prefix "rake 'cem:spec_standalone#{rake_args(nil, *args)}'"
     end
 
     def cmd_parallel(*args)
-      "bundle exec rake 'cem:parallel_spec_standalone#{rake_args(*args)}'"
+      prefix "rake 'cem:parallel_spec_standalone#{rake_args(*args)}'"
     end
 
     def cmd_chunked(*files)
-      "bundle exec rake 'cem:parallel_spec_files#{rake_args(files.join(' '))}'"
+      prefix "rake 'cem:parallel_spec_files#{rake_args(files.join(' '))}'"
     end
 
     def prep_cmd
-      'bundle exec rake cem:win_spec_prep'
+      prefix 'rake cem:win_spec_prep'
     end
 
     def cmds(*args)
@@ -31,7 +32,7 @@ module CemWinSpec
     end
 
     def cleanup_cmd
-      'bundle exec rake cem:win_spec_clean'
+      prefix 'rake cem:win_spec_clean'
     end
 
     def spec_files
@@ -40,12 +41,16 @@ module CemWinSpec
 
     private
 
+    def prefix(cmd)
+      @use_bundler ? "bundle exec #{cmd}" : cmd
+    end
+
     def rake_args(*args)
       args.empty? ? '' : "[#{args.join(',')}]"
     end
 
     def rspec_cmd(file, *args)
-      "bundle exec rake 'cem:spec_standalone#{rake_args(file, *args)}'"
+      prefix "rake 'cem:spec_standalone#{rake_args(file, *args)}'"
     end
   end
 end

data/lib/cem_win_spec/test_runner.rb

@@ -38,7 +38,7 @@ module CemWinSpec
 
     def enable_long_paths(**opts)
       new_command('Enable long paths', **opts) do
-        remote_exec('Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1')
+        remote_run('Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1')
       end
     end
 
@@ -68,7 +68,7 @@ module CemWinSpec
         module_archive_build { |a| remote_upload(a, remote_working_dir) }
         module_dir = "#{remote_working_dir}\\#{File.basename(module_archive_path, '.tar.gz')}"
         logger.debug "Module uploaded to #{module_dir}.tar.gz, extracting..."
-        remote_exec("tar -xzf #{module_dir}.tar.gz -C #{remote_working_dir}")
+        remote_run("tar -xzf #{module_dir}.tar.gz -C #{remote_working_dir}")
         logger.debug "Module extracted to #{module_dir}"
         module_dir
       end
@@ -76,33 +76,33 @@ module CemWinSpec
 
     def setup_ruby(**opts)
       @setup_ruby ||= new_command('Set up ruby', **opts) do
-        remote_exec('bundle config disable_platform_warnings true')
-        remote_exec('bundle install')
+        remote_run('bundle config disable_platform_warnings true')
+        remote_run('bundle install')
       end
     end
 
     def rspec_prep(**opts)
       @rspec_prep ||= new_command('Prepare rspec tests', **opts) do
-        remote_exec('bundle exec rake cem_win_spec:prep --trace')
+        remote_run('bundle exec rake cem_win_spec:prep --trace')
       end
     end
 
     def rspec_tests(**opts)
       @rspec_tests ||= new_command('Run rspec tests', **opts) do
-        remote_exec(rspec_cmd_standalone('false', 'progress', 'true'))
+        remote_run(rspec_cmd_standalone('false', 'progress', 'true'))
       end
     end
 
     def rspec_tests_parallel(**opts)
       @rspec_tests_parallel ||= new_command('Run rspec tests in parallel', **opts) do
-        remote_exec('bundle exec rake cem_win_spec:parallel_spec')
+        remote_run('bundle exec rake cem_win_spec:parallel_spec')
       end
     end
 
     def clean_up
       @clean_up ||= new_command('Cleanup') do |working_dir|
         if remote_available?
-          remote_exec(cleanup_cmd, quiet: true)
+          remote_run(cleanup_cmd, quiet: true)
         else
           logger.warn 'Cleanup not available'
         end
@@ -111,7 +111,7 @@ module CemWinSpec
 
     def clean_fixture_cache(**opts)
       @clean_cache ||= new_command('Clean fixture cache', **opts) do
-        remote_exec('bundle exec rake cem_win_spec:clean_fixture_cache')
+        remote_run('bundle exec rake cem_win_spec:clean_fixture_cache')
       end
     end
 

data/lib/cem_win_spec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CemWinSpec
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/cem_win_spec/win_exec/cmd/base_cmd.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../../logging'
+
+module CemWinSpec
+  module WinExec
+    class BaseCmd
+      include CemWinSpec::Logging
+
+      COMMAND_SEPARATOR = '; '
+      PUPPET_VER_TO_RUBY_VER = {
+        '7' => '278',
+        '8' => '322',
+      }.freeze
+
+      attr_accessor :working_dir, :env_vars, :puppet_version
+
+      def initialize(working_dir = nil, puppet_version: nil, **env_vars)
+        @working_dir = working_dir
+        self.puppet_version = puppet_version
+        self.env_vars = env_vars
+      end
+
+      # Sets the puppet version that will be used to execute the command
+      # @param value [String, nil] the puppet version
+      def puppet_version=(value)
+        if value.nil?
+          @puppet_version = nil
+          return
+        end
+
+        ver = value.to_s
+        raise ArgumentError, 'puppet_version only supports major versions 7 and 8' unless ver.match?(/^(7|8).*/)
+        unless ver.match?(/^(7|8)(\.\d+)?\.\d+$/)
+          ver = "#{ver}.0"
+        end
+
+        @puppet_version = ver
+      end
+
+      # Sets the environment variables that will be used to execute the command
+      # @param value [Hash] the environment variables
+      def env_vars=(value)
+        raise ArgumentError, 'env_vars must be a hash' unless value.is_a?(Hash)
+
+        value['PUPPET_GEM_VERSION'] = "~> #{puppet_version}" if puppet_version
+        value['FACTER_GEM_VERSION'] = 'https://github.com/puppetlabs/facter#main' if puppet_version
+        @env_vars = value
+      end
+
+      def available?
+        raise NotImplementedError
+      end
+
+      def run(cmd, *_args, **_kwargs)
+        raise NotImplementedError
+      end
+
+      # Returns the ruby version that will be used to execute the command
+      # The ruby version is determined by the puppet version that is set
+      # @return [String, nil] the ruby version or nil if the puppet version is not set
+      def ruby_version
+        return nil unless puppet_version
+
+        PUPPET_VER_TO_RUBY_VER[puppet_version.split('.')[0]]
+      end
+
+      def command(cmd)
+        cmd = [cmd]
+        cmd.unshift(change_ruby_version_cmd) if ruby_version # executes third
+        env_vars.each { |k, v| cmd.unshift(set_env_var_cmd(k, v)) } if env_vars.any? # executes second
+        cmd.unshift(change_working_dir_cmd(working_dir)) if working_dir # executes first
+        cmd.join(COMMAND_SEPARATOR)
+      end
+
+      private
+
+      def log_command(cmd)
+        cmd = command(cmd)
+        logger.debug "Executing command:\n#{cmd.split(%r{\n|\r\n|;\s*}).map { |c| "  #> #{c}" }.join("\n")}"
+      end
+
+      def change_ruby_version_cmd
+        "uru #{ruby_version}"
+      end
+
+      def set_env_var_cmd(key, value)
+        "set #{key}=\"#{value}\""
+      end
+
+      def change_working_dir_cmd(dir)
+        "cd #{dir}"
+      end
+    end
+  end
+end

data/lib/cem_win_spec/win_exec/{local_exec.rb → cmd/local_cmd.rb}

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 require 'open3'
-require_relative 'base_exec'
+require_relative 'base_cmd'
 
 module CemWinSpec
   module WinExec
     # Class for executing local shell commands
-    class LocalExec < BaseExec
+    class LocalCmd < BaseCmd
       attr_reader :thread_results
 
-      def initialize(working_dir = nil)
+      def initialize(working_dir = nil, puppet_version: nil, **env_vars)
         @ran_in_thread = false
         @thread_results = {}
-        super(working_dir)
+        super(working_dir, puppet_version: puppet_version, **env_vars)
       end
 
       def available?
@@ -35,9 +35,9 @@ module CemWinSpec
       # This is useful for running commands that should not block the current process
       # and that you don't need stdout/stderr from.
       # @param cmd [String] The command to execute
-      def bg_exec(cmd, *_args, **_kwargs)
-        puts_cmd(cmd)
-        Process.detach(spawn(cd_working_dir(cmd)))
+      def bg_run(cmd, *_args, **_kwargs)
+        log_command(cmd)
+        Process.detach(spawn(command(cmd)))
       end
 
       # Execute a command in a new thread. This works by creating a new thread in a thread group
@@ -48,20 +48,20 @@ module CemWinSpec
       # Process::Status object.
       # @param cmd [String] The command to execute
       # @return [Array] An array of [:threaded, cmd]
-      def thread_exec(cmd, *_args, **_kwargs)
+      def thread_run(cmd, *_args, **_kwargs)
         @ran_in_thread = true
         th = Thread.new do
-          puts_cmd(cmd)
-          so, se, st = Open3.capture3(cd_working_dir(cmd))
+          log_command(cmd)
+          so, se, st = Open3.capture3(command(cmd))
           @thread_results[cmd] = [so, se, st]
         end
         thread_group.add th
         :threaded
       end
 
-      def exec(cmd, *_args, **_kwargs)
-        puts_cmd(cmd)
-        Open3.capture3(cd_working_dir(cmd))
+      def run(cmd, *_args, **_kwargs)
+        log_command(cmd)
+        Open3.capture3(command(cmd))
       end
 
       private

data/lib/cem_win_spec/win_exec/{winrm_exec.rb → cmd/winrm_cmd.rb}

@@ -2,32 +2,32 @@
 
 require 'winrm'
 require 'winrm-fs'
-require_relative 'base_exec'
+require_relative 'base_cmd'
 
 module CemWinSpec
   module WinExec
     # Class for executing PowerShell commands over WinRM
-    class WinRMExec < BaseExec
+    class WinRMCmd < BaseCmd
       attr_reader :conn_opts
 
-      def initialize(conn_opts, working_dir = nil, quiet: false)
+      def initialize(conn_opts, working_dir = nil, quiet: false, puppet_version: nil, **env_vars)
         @conn_opts = conn_opts
         @quiet = quiet
         @conn = new_conn(@conn_opts.to_h)
-        super(working_dir)
+        super(working_dir, puppet_version: puppet_version, **env_vars)
       end
 
       def available?
         @available
       end
 
-      def exec(cmd, *_args, **_kwargs)
-        puts_cmd(cmd)
+      def run(cmd, *_args, **_kwargs)
+        log_command(cmd)
         shell = nil
         output = nil
         begin
           shell = conn.shell(:powershell)
-          output = shell.run(cd_working_dir(cmd))
+          output = shell.run(command(cmd))
         rescue WinRM::WinRMAuthorizationError => e
           @available = false
           raise e
@@ -77,10 +77,19 @@ module CemWinSpec
       def new_conn(hash_opts)
         logger.debug "Creating connection to #{hash_opts[:endpoint]}"
         new_conn = WinRM::Connection.new(hash_opts)
-        new_conn.logger = logger
+        new_conn.logger = new_conn_logger
         new_conn
       end
 
+      def new_conn_logger
+        conn_logger = logger.dup
+        conn_logger.level = Logger::ERROR if @quiet
+        conn_logger.level = Logger::DEBUG if ENV['WINRM_DEBUG'] == 'true'
+        conn_logger.level = Logger::INFO if conn_logger.level == Logger::DEBUG && ENV.fetch('WINRM_DEBUG', 'false') != 'true'
+        logger.debug "WinRM connection logger level set to #{conn_logger.level}"
+        conn_logger
+      end
+
       def file_manager
         @file_manager ||= WinRM::FS::FileManager.new(conn)
       end

data/lib/cem_win_spec/win_exec/connection_opts.rb

@@ -49,7 +49,7 @@ module CemWinSpec
       end
 
       def pass
-        @pass ||= Digest::SHA256.hexdigest(pt_pass) unless pt_pass.nil?
+        Digest::SHA256.hexdigest(pt_pass) unless pt_pass.nil?
       end
 
       def endpoint
@@ -57,7 +57,7 @@ module CemWinSpec
       end
 
       def opts
-        @opts ||= new_opts(@kwargs)
+        @opts ||= create_new_opts(@kwargs)
       end
 
       def ==(other)
@@ -75,14 +75,14 @@ module CemWinSpec
       end
 
       def digest
-        Digest::SHA256.hexdigest([host, port, user, @pass, opts.values].join(':'))
+        Digest::SHA256.hexdigest([host, port, user, pt_pass, opts.values].join(':'))
       end
 
       # Merge new options into existing options and return a new ConnectionOpts object
       # @param [Hash] new_opts
       # @return [ConnectionOpts]
       def merge(**new_opts)
-        self.class.new(opts_merge(**new_opts))
+        self.class.new(**opts_merge(**new_opts))
       end
 
       def merge!(**new_opts)
@@ -139,7 +139,7 @@ module CemWinSpec
         password
       end
 
-      def new_opts(nopts = {})
+      def create_new_opts(nopts = {})
         logger.debug 'Creating new connection options opts'
         new_opts_h = CONN_DEFAULTS.dup.merge(nopts)
         new_opts_h[:transport] = new_opts_h[:transport].to_sym

data/lib/cem_win_spec/win_exec/exec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require_relative '../logging'
+require_relative 'output'
+
+module CemWinSpec
+  module WinExec
+    # Class for executing PowerShell commands over WinRM
+    class Exec
+      include CemWinSpec::Logging
+
+      HALTING_ERRORS = [
+        IapTunnelStartError,
+      ].freeze
+
+      attr_reader :title, :result, :reuse_tunnel, :ignore_exitcode
+
+      def initialize(title: 'Command', l_cmd: nil, r_cmd: nil, iap_tunnel: nil, ma_builder: nil, r_test_cmds: nil, &block)
+        add_title(title)
+        add_local_cmd(l_cmd) unless l_cmd.nil?
+        add_remote_cmd(r_cmd) unless r_cmd.nil?
+        add_iap_tunnel(iap_tunnel) unless iap_tunnel.nil?
+        add_ma_builder(ma_builder) unless ma_builder.nil?
+        add_rspec_test_cmds(r_test_cmds) unless r_test_cmds.nil?
+        add_command_block(&block) unless block.nil?
+        @reuse_tunnel = true
+        @ignore_exitcode = false
+        @spinner = nil
+        @result = nil
+      end
+
+      def add_title(value)
+        raise ArgumentError, 'title must be a string' unless value.is_a?(String)
+
+        @title = value
+      end
+
+      def add_local_cmd(value)
+        raise ArgumentError, 'local_exec must implement the #run method' unless value.respond_to?(:run)
+        
+        @local_cmd = value
+      end
+
+      def add_remote_cmd(value)
+        raise ArgumentError, 'winrm_exec must implement the #run method' unless value.respond_to?(:run)
+
+        @remote_cmd = value
+      end
+
+      def add_iap_tunnel(value)
+        unless value.respond_to?(:start) && value.respond_to?(:stop) && value.respond_to?(:with)
+          raise ArgumentError, 'iap_tunnel must implement the #start, #stop, and #with methods'
+        end
+
+        @iap_tunnel = value
+      end
+
+      def add_ma_builder(value)
+        raise ArgumentError, 'ma_builder must implement the #build method' unless value.respond_to?(:build)
+
+        @ma_builder = value
+      end
+
+      def add_rspec_test_cmds(value)
+        unless value.respond_to?(:cmd_standalone) && value.respond_to?(:cmd_parallel) &&
+               value.respond_to?(:prep_cmd) && value.respond_to?(:cleanup_cmd)
+          raise ArgumentError, 'rspec_test_cmds must implement the #cmd_standalone, #cmd_parallel, #prep_cmd, and #cleanup_cmd methods'
+        end
+
+        @rspec_test_cmds = value
+      end
+
+      def add_command_block(&block)
+        raise ArgumentError, 'block must be a Proc' unless block.is_a?(Proc)
+
+        @block = block
+      end
+
+      def reuse_tunnel=(value)
+        raise ArgumentError, 'reuse_tunnel must be a boolean' unless [true, false].include?(value)
+
+        @reuse_tunnel = value
+      end
+      alias reuse_tunnel? reuse_tunnel
+
+      def ignore_exitcode=(value)
+        raise ArgumentError, 'ignore_exitcode must be a boolean' unless [true, false].include?(value)
+
+        @ignore_exitcode = value
+      end
+      alias ignore_exitcode? ignore_exitcode
+  
+      def success?
+        @result.success? if @result.is_a?(Output)
+
+        false
+      end
+
+      def spinner=(value)
+        raise ArgumentError, 'spinner must implement #auto_spin and #stop methods' unless value.respond_to?(:auto_spin) && value.respond_to?(:stop)
+
+        @spinner = value
+      end
+
+      # Proxy method calls for methods that don't exist here to various other objects.
+      # This allows doing things like: `win_exec.remote_exec('Get-Process')` and
+      # calling the `exec` method on the `winrm_exec` object. This is done by
+      # checking method name prefixes and calling the corresponding method on the
+      # appropriate object. The prefix is removed from the method name before
+      # calling the method on the object. The supported prefixes are:
+      #   local_ - calls the method on the @local_cmd object
+      #   remote_ - calls the method on the @remote_cmd object
+      #   rspec_ - calls the method on the @rspec_test_cmds object
+      #   module_archive_ - calls the method on the @ma_builder object
+      def method_missing(method, *args, **kwargs, &block)
+        if method.to_s.start_with?('local_') # proxy to local_exec
+          method = method.to_s.sub('local_', '').to_sym
+          @local_cmd.send(method, *args, **kwargs, &block)
+        elsif method.to_s.start_with?('remote_') # proxy to remote_exec
+          method = method.to_s.sub('remote_', '').to_sym
+          @remote_cmd.send(method, *args, **kwargs, &block)
+        elsif method.to_s.start_with?('rspec_') # proxy to rspec_test_cmds
+          method = method.to_s.sub('rspec_', '').to_sym
+          @rspec_test_cmds.send(method, *args, **kwargs, &block)
+        elsif method.to_s.start_with?('module_archive_') # proxy to ma_builder
+          method = method.to_s.sub('module_archive_', '').to_sym
+          @ma_builder.send(method, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      # Proxy respond_to? for methods that don't exist here to various other objects.
+      # This allows doing things like: `win_exec.respond_to?(:remote_exec)` and
+      # checking if the `exec` method exists on the `winrm_exec` object. This is done by
+      # checking method name prefixes and calling the corresponding method on the
+      # appropriate object. The prefix is removed from the method name before
+      # calling the method on the object. The supported prefixes are:
+      #   local_ - calls the method on the @local_cmd object
+      #   remote_ - calls the method on the @remote_cmd object
+      #   rspec_ - calls the method on the @rspec_test_cmds object
+      #   module_archive_ - calls the method on the @ma_builder object
+      def respond_to_missing?(method, include_private = false)
+        if method.to_s.start_with?('local_')
+          @local_cmd.respond_to?(method.to_s.sub('local_', '').to_sym, include_private)
+        elsif method.to_s.start_with?('remote_')
+          @remote_cmd.respond_to?(method.to_s.sub('remote_', '').to_sym, include_private)
+        elsif method.to_s.start_with?('rspec_')
+          @rspec_test_cmds.respond_to?(method.to_s.sub('rspec_', '').to_sym, include_private)
+        elsif method.to_s.start_with?('module_archive_')
+          @ma_builder.respond_to?(method.to_s.sub('module_archive_', '').to_sym, include_private)
+        else
+          super
+        end
+      end
+  
+      def run(*args, **kwargs)
+        validate_instance_variables
+        logger.info "Running #{@title}"
+        @spinner&.auto_spin
+        result = run_with_tunnel { run_in_current_scope(*args, **kwargs) }
+        @spinner&.stop
+        @result = Output.new(result)
+        return if @result.pending_threaded?
+
+        @result.puts_combined
+        unless @result.success? || ignore_exitcode?
+          raise "Command failed with exit code #{@result.exitcode}: #{@result.stdout}\n#{@result.stderr}"
+        end
+        @result
+      rescue StandardError => e
+        raise if HALTING_ERRORS.include?(e.class)
+
+        logger.error "Error running #{@title}: #{e.message[0..100]}"
+        @result = Output.new(e)
+        @result
+      end
+
+      private
+
+      def run_with_tunnel(&block)
+        if reuse_tunnel?
+          @iap_tunnel.start # ensure tunnel is running
+          block.call
+        else
+          @iap_tunnel.stop # ensure tunnel is stopped
+          @iap_tunnel.with do # start tunnel for this block
+            block.call
+          end
+        end
+      end
+
+      def validate_instance_variables
+        %i[@title @local_cmd @remote_cmd @iap_tunnel @ma_builder @rspec_test_cmds @block].each do |var|
+          raise ArgumentError, "#{var} must be set" if instance_variable_get(var).nil?
+        end
+      end
+
+      # Runs the block in the current scope. This allows the block to access
+      # instance variables and methods from the current scope.
+      def run_in_current_scope(*args, **kwargs)
+        instance_exec(*args, **kwargs, &@block) # self is the "instance"
+      end
+
+      def wrap_spinner
+        @spinner.auto_spin if @spinner
+        yield if block_given?
+      ensure
+        @spinner.stop if @spinner
+      end
+    end
+  end
+end

data/lib/cem_win_spec/win_exec/factory.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative '../logging'
+require_relative 'connection_opts'
+require_relative 'cmd/local_cmd'
+require_relative 'cmd/winrm_cmd'
+
+module CemWinSpec
+  module WinExec
+    # Factory class for creating a WinExec object
+    class Factory
+      include CemWinSpec::Logging
+
+      attr_reader :current_local_exec, :current_remote_cmd, :current_conn_opts
+
+      def initialize(iap_tunnel, ma_builder, rspec_test_cmds, **opts)
+        @iap_tunnel = iap_tunnel
+        @ma_builder = ma_builder
+        @rspec_test_cmds = rspec_test_cmds
+        @current_local_cmd = LocalCmd.new(**opts)
+        @current_remote_cmd = nil
+        @current_conn_opts = nil
+        @init_opts = opts
+      end
+
+      # Build a WinExec object
+      # @param title [String] Title of the WinExec object
+      # @param merge [Boolean] Merge the current connection options with the new options, if applicable
+      # @param host [String] Hostname or IP address of the remote host
+      # @param port [Integer] Port of the remote host
+      # @param user [String] Username for the remote host
+      # @param pass [String] Password for the remote host
+      # @param opts [Hash] Additional options for the WinRM connection
+      # @return [Exec] An Exec object
+      def build(title, merge: true, user: nil, pass: nil, working_dir: nil, **opts, &block)
+        logger.debug "Building Wexec object for #{title}"
+        build_conn_opts(merge: merge, user: user, pass: pass, **opts)
+        logger.debug 'Created ConnectionOpts'
+        wexec = Exec.new
+        wexec.add_title title
+        wexec.add_local_cmd @current_local_cmd
+        wexec.add_remote_cmd get_remote_cmd(working_dir, **@init_opts.merge(opts))
+        wexec.add_iap_tunnel @iap_tunnel
+        wexec.add_ma_builder @ma_builder
+        wexec.add_rspec_test_cmds @rspec_test_cmds
+        wexec.add_command_block(&block)
+        wexec.reuse_tunnel = opts[:reuse_tunnel] if opts.key?(:reuse_tunnel)
+        wexec.ignore_exitcode = opts[:ignore_exitcode] if opts.key?(:ignore_exitcode)
+        wexec.spinner = opts[:spinner] if opts.key?(:spinner)
+        logger.debug 'Created Wexec'
+        wexec
+      end
+
+      def local_threaded_results
+        logger.info 'Checking for deferred results...'
+        @current_local_exec.join_threads
+        @current_local_exec.threaded_results.each do |cmd, results|
+          logger.info "Deferred results for #{cmd}:"
+          Output.new(results).puts_combined
+        end
+      end
+
+      private
+
+      def build_conn_opts(merge: true, user: nil, pass: nil, **opts)
+        if @current_conn_opts.nil?
+          logger.debug 'Creating new ConnectionOpts object'
+          @current_conn_opts = ConnectionOpts.new(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          return @current_conn_opts
+        end
+        
+        if need_new_conn_opts?(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          if merge
+            logger.debug 'Merging ConnectionOpts with new options'
+            @current_conn_opts = @current_conn_opts.merge(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          else
+            logger.debug 'Creating new ConnectionOpts object with new options'
+            @current_conn_opts = ConnectionOpts.new(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
+          end
+        else
+          logger.debug 'Returning existing ConnectionOpts object'
+        end
+        @current_conn_opts
+      end
+
+      def need_new_conn_opts?(new_host: nil, new_port: nil, user: nil, pass: nil, **opts)
+        if new_host && new_host != @current_conn_opts.host
+          logger.debug "New host #{new_host} does not match current host #{@current_conn_opts.host}"
+          return true
+        end
+        if new_port && new_port != @current_conn_opts.port
+          logger.debug "New port #{new_port} does not match current port #{@current_conn_opts.port}"
+          return true
+        end
+        if user && user != @current_conn_opts.user
+          logger.debug "New user #{user} does not match current user #{@current_conn_opts.user}"
+          return true
+        end
+        if pass && Digest::SHA256.hexdigest(pass) != @current_conn_opts.pass
+          logger.debug 'New password does not match current password'
+          return true
+        end
+        if !opts.empty? && opts != @current_conn_opts.opts
+          logger.debug "New extra options #{opts} do not match current extra options #{@current_conn_opts.opts}"
+          return true
+        end
+
+        false
+      end
+
+      def get_remote_cmd(working_dir = nil, **opts)
+        if @current_winrm_cmd.nil? || @current_winrm_cmd.conn_opts.digest != @current_conn_opts.digest
+          logger.debug 'Creating new WinRMExec object'
+          @current_remote_cmd = WinRMCmd.new(@current_conn_opts, **opts)
+        end
+        logger.debug "Setting working directory to #{working_dir}" unless working_dir.nil?
+        @current_remote_cmd.working_dir = working_dir
+        logger.debug 'Returning WinRMExec object'
+        @current_remote_cmd
+      end
+    end
+  end
+end

data/lib/cem_win_spec/win_exec.rb

@@ -1,234 +1,8 @@
 # frozen_string_literal: true
 
-require 'digest'
-require_relative 'iap_tunnel'
-require_relative 'logging'
-require_relative 'module_archive_builder'
-require_relative 'win_exec/connection_opts'
-require_relative 'win_exec/local_exec'
-require_relative 'win_exec/winrm_exec'
-require_relative 'win_exec/output'
-
 module CemWinSpec
   module WinExec
-    # Class for executing PowerShell commands over WinRM
-    class Exec
-      include CemWinSpec::Logging
-
-      attr_reader :title, :result, :reuse_tunnel, :ignore_exitcode
-
-      def initialize(title, local_exec, winrm_exec, iap_tunnel, ma_builder, rspec_test_cmds, &block)
-        @title = title
-        @local_exec = local_exec
-        @winrm_exec = winrm_exec
-        @iap_tunnel = iap_tunnel
-        @ma_builder = ma_builder
-        @rspec_test_cmds = rspec_test_cmds
-        @block = block
-        @reuse_tunnel = true
-        @ignore_exitcode = false
-        @spinner = nil
-        @result = nil
-      end
-
-      def reuse_tunnel=(value)
-        raise ArgumentError, 'reuse_tunnel must be a boolean' unless [true, false].include?(value)
-
-        @reuse_tunnel = value
-      end
-      alias reuse_tunnel? reuse_tunnel
-
-      def ignore_exitcode=(value)
-        raise ArgumentError, 'ignore_exitcode must be a boolean' unless [true, false].include?(value)
-
-        @ignore_exitcode = value
-      end
-      alias ignore_exitcode? ignore_exitcode
-  
-      def success?
-        @result.success? if @result.is_a?(Output)
-
-        false
-      end
-
-      def spinner=(value)
-        raise ArgumentError, 'spinner must implement #auto_spin and #stop methods' unless value.respond_to?(:auto_spin) && value.respond_to?(:stop)
-
-        @spinner = value
-      end
-
-      # Proxy method calls for methods that don't exist here to various other objects.
-      # This allows doing things like: `win_exec.remote_exec('Get-Process')` and
-      # calling the `exec` method on the `winrm_exec` object. This is done by
-      # checking method name prefixes and calling the corresponding method on the
-      # appropriate object. The prefix is removed from the method name before
-      # calling the method on the object. The supported prefixes are:
-      #   local_ - calls the method on the @local_exec object
-      #   remote_ - calls the method on the @winrm_exec object
-      #   rspec_ - calls the method on the @rspec_test_cmds object
-      #   module_archive_ - calls the method on the @ma_builder object
-      def method_missing(method, *args, **kwargs, &block)
-        if method.to_s.start_with?('local_') # proxy to local_exec
-          method = method.to_s.sub('local_', '').to_sym
-          @local_exec.send(method, *args, **kwargs, &block)
-        elsif method.to_s.start_with?('remote_') # proxy to winrm_exec
-          method = method.to_s.sub('remote_', '').to_sym
-          @winrm_exec.send(method, *args, **kwargs, &block)
-        elsif method.to_s.start_with?('rspec_') # proxy to rspec_test_cmds
-          method = method.to_s.sub('rspec_', '').to_sym
-          @rspec_test_cmds.send(method, *args, **kwargs, &block)
-        elsif method.to_s.start_with?('module_archive_') # proxy to ma_builder
-          method = method.to_s.sub('module_archive_', '').to_sym
-          @ma_builder.send(method, *args, **kwargs, &block)
-        else
-          super
-        end
-      end
-
-      # Proxy respond_to? for methods that don't exist here to various other objects.
-      # This allows doing things like: `win_exec.respond_to?(:remote_exec)` and
-      # checking if the `exec` method exists on the `winrm_exec` object. This is done by
-      # checking method name prefixes and calling the corresponding method on the
-      # appropriate object. The prefix is removed from the method name before
-      # calling the method on the object. The supported prefixes are:
-      #   local_ - calls the method on the @local_exec object
-      #   remote_ - calls the method on the @winrm_exec object
-      #   rspec_ - calls the method on the @rspec_test_cmds object
-      #   module_archive_ - calls the method on the @ma_builder object
-      def respond_to_missing?(method, include_private = false)
-        if method.to_s.start_with?('local_')
-          @local_exec.respond_to?(method.to_s.sub('local_', '').to_sym, include_private)
-        elsif method.to_s.start_with?('remote_')
-          @winrm_exec.respond_to?(method.to_s.sub('remote_', '').to_sym, include_private)
-        elsif method.to_s.start_with?('rspec_')
-          @rspec_test_cmds.respond_to?(method.to_s.sub('rspec_', '').to_sym, include_private)
-        elsif method.to_s.start_with?('module_archive_')
-          @ma_builder.respond_to?(method.to_s.sub('module_archive_', '').to_sym, include_private)
-        else
-          super
-        end
-      end
-  
-      def run(*args, **kwargs)
-        logger.info "Running #{@title}"
-        @spinner&.auto_spin
-        result = if reuse_tunnel?
-                   @iap_tunnel.start # ensure tunnel is running
-                   run_in_current_scope(*args, **kwargs)
-                 else
-                   @iap_tunnel.stop # ensure tunnel is stopped
-                   @iap_tunnel.with do # start tunnel for this block
-                     run_in_current_scope(*args, **kwargs)
-                   end
-                 end
-        @spinner&.stop
-        @result = Output.new(result)
-        return if @result.pending_threaded?
-
-        @result.puts_combined
-        unless @result.success? || ignore_exitcode?
-          raise "Command failed with exit code #{@result.exitcode}: #{@result.stdout}\n#{@result.stderr}"
-        end
-        @result
-      rescue StandardError => e
-        logger.error "Error running #{@title}: #{e.message[0..100]}"
-        @result = Output.new(e)
-        @result
-      end
-
-      private
-
-      def run_in_current_scope(*args, **kwargs)
-        instance_exec(*args, **kwargs, &@block)
-      end
-
-      def wrap_spinner
-        @spinner.auto_spin if @spinner
-        yield if block_given?
-      ensure
-        @spinner.stop if @spinner
-      end
-    end
-
-    # Factory class for creating a WinExec object
-    class Factory
-      include CemWinSpec::Logging
-
-      attr_reader :current_local_exec, :current_winrm_exec, :current_conn_opts
-
-      def initialize(iap_tunnel, ma_builder, rspec_test_cmds)
-        @iap_tunnel = iap_tunnel
-        @ma_builder = ma_builder
-        @rspec_test_cmds = rspec_test_cmds
-        @current_local_exec = LocalExec.new
-        @current_winrm_exec = nil
-        @current_conn_opts = nil
-      end
-
-      # Build a WinExec object
-      # @param title [String] Title of the WinExec object
-      # @param merge [Boolean] Merge the current connection options with the new options, if applicable
-      # @param host [String] Hostname or IP address of the remote host
-      # @param port [Integer] Port of the remote host
-      # @param user [String] Username for the remote host
-      # @param pass [String] Password for the remote host
-      # @param opts [Hash] Additional options for the WinRM connection
-      # @return [Exec] An Exec object
-      def build(title, merge: true, user: nil, pass: nil, working_dir: nil, **opts, &block)
-        logger.debug "Building Wexec object for #{title}"
-        build_conn_opts(merge: merge, user: user, pass: pass, **opts)
-        logger.debug 'Created ConnectionOpts'
-        wexec = Exec.new(title, @current_local_exec, get_winrm_exec(working_dir), @iap_tunnel, @ma_builder, @rspec_test_cmds, &block)
-        wexec.reuse_tunnel = opts[:reuse_tunnel] if opts.key?(:reuse_tunnel)
-        wexec.ignore_exitcode = opts[:ignore_exitcode] if opts.key?(:ignore_exitcode)
-        wexec.spinner = opts[:spinner] if opts.key?(:spinner)
-        logger.debug 'Created Wexec'
-        wexec
-      end
-
-      def local_threaded_results
-        logger.info 'Checking for deferred results...'
-        @current_local_exec.join_threads
-        @current_local_exec.threaded_results.each do |cmd, results|
-          logger.info "Deferred results for #{cmd}:"
-          Output.new(results).puts_combined
-        end
-      end
-
-      private
-
-      def build_conn_opts(merge: true, user: nil, pass: nil, **opts)
-        if @current_conn_opts.nil?
-          logger.debug 'Creating new ConnectionOpts object'
-          @current_conn_opts = ConnectionOpts.new(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
-          return @current_conn_opts
-        end
-        opts_digest = Digest::SHA256.hexdigest(['localhost', @iap_tunnel.port, user, pass, opts].join(':'))
-        if opts_digest != @current_conn_opts.digest
-          if merge
-            logger.debug 'Merging ConnectionOpts with new options'
-            @current_conn_opts = @current_conn_opts.merge(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
-          else
-            logger.debug 'Creating new ConnectionOpts object with new options'
-            @current_conn_opts = ConnectionOpts.new(new_host: 'localhost', new_port: @iap_tunnel.port, user: user, pass: pass, **opts)
-          end
-        else
-          logger.debug 'Returning existing ConnectionOpts object'
-        end
-        @current_conn_opts
-      end
-
-
-      def get_winrm_exec(working_dir = nil)
-        if @current_winrm_exec.nil? || @current_winrm_exec.conn_opts.digest != @current_conn_opts.digest
-          logger.debug 'Creating new WinRMExec object'
-          @current_winrm_exec = WinRMExec.new(@current_conn_opts)
-        end
-        logger.debug "Setting working directory to #{working_dir}" unless working_dir.nil?
-        @current_winrm_exec.working_dir = working_dir
-        logger.debug 'Returning WinRMExec object'
-        @current_winrm_exec
-      end
-    end
+    require_relative 'win_exec/exec'
+    require_relative 'win_exec/factory'
   end
 end

data/lib/cem_win_spec.rb

@@ -45,14 +45,14 @@ module CemWinSpec
       check_output!(sre_out, runner)
       module_dir = sre_out.stdout.chomp
       logger.debug "Module dir: #{module_dir}"
-      srr_out = setup_remote_ruby(runner, module_dir, spinner)
+      srr_out = setup_remote_ruby(runner, module_dir, spinner, **options)
       check_output!(srr_out, runner)
       case operation
       when :spec
-        spec_out = run_spec(runner, module_dir, spinner)
+        spec_out = run_spec(runner, module_dir, spinner, **options)
         check_output!(spec_out, runner)
       when :clean_fixture_cache
-        clean_fixture_cache_out = clean_fixture_cache(runner, module_dir, spinner)
+        clean_fixture_cache_out = clean_fixture_cache(runner, module_dir, spinner, **options)
         check_output!(clean_fixture_cache_out, runner)
       else
         raise ArgumentError, "Unknown operation: #{operation}"
@@ -71,32 +71,34 @@ module CemWinSpec
     working_dir_out = runner.create_working_dir.run
     working_dir = working_dir_out.stdout.chomp
     logger.debug "Working dir: #{working_dir}"
-    runner.upload_module(working_dir: working_dir).run
+    runner.upload_module(operation_timeout: 300, receive_timeout: 310, working_dir: working_dir).run
   end
 
-  def self.setup_remote_ruby(runner, module_dir, spinner)
+  def self.setup_remote_ruby(runner, module_dir, spinner, **opts)
     runner.setup_ruby(operation_timeout: 300,
                       receive_timeout: 310,
                       working_dir: module_dir,
                       reuse_tunnel: false,
-                      spinner: spinner).run
+                      spinner: spinner,
+                      **opts).run
   end
 
   # Runs RSpec tests
-  def self.run_spec(runner, module_dir, spinner)
+  def self.run_spec(runner, module_dir, spinner, **opts)
     #runner.rspec_prep(working_dir: module_dir, reuse_tunnel: false, spinner: spinner).run
     runner.rspec_tests_parallel(operation_timeout: 300,
                                 receive_timeout: 310,
                                 working_dir: module_dir,
                                 ignore_exitcode: true,
                                 reuse_tunnel: false,
-                                spinner: spinner).run
+                                spinner: spinner,
+                                **opts).run
   end
 
   # Clean the remote fixture cache
   # @param options [Hash] Options for the test runner
-  def self.clean_fixture_cache(runner, module_dir, spinner)
-    runner.clean_fixture_cache(working_dir: module_dir, spinner: spinner).run
+  def self.clean_fixture_cache(runner, module_dir, spinner, **opts)
+    runner.clean_fixture_cache(working_dir: module_dir, spinner: spinner, **opts).run
   end
 
   def self.check_output!(output, runner = nil)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cem_win_spec
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Heston Snodgrass
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-13 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: winrm
@@ -119,16 +119,17 @@ files:
 - lib/cem_win_spec/logging/formatter.rb
 - lib/cem_win_spec/module_archive_builder.rb
 - lib/cem_win_spec/rake_tasks.rb
-- lib/cem_win_spec/remote_command.rb
 - lib/cem_win_spec/rspec_test_cmds.rb
 - lib/cem_win_spec/test_runner.rb
 - lib/cem_win_spec/version.rb
 - lib/cem_win_spec/win_exec.rb
-- lib/cem_win_spec/win_exec/base_exec.rb
+- lib/cem_win_spec/win_exec/cmd/base_cmd.rb
+- lib/cem_win_spec/win_exec/cmd/local_cmd.rb
+- lib/cem_win_spec/win_exec/cmd/winrm_cmd.rb
 - lib/cem_win_spec/win_exec/connection_opts.rb
-- lib/cem_win_spec/win_exec/local_exec.rb
+- lib/cem_win_spec/win_exec/exec.rb
+- lib/cem_win_spec/win_exec/factory.rb
 - lib/cem_win_spec/win_exec/output.rb
-- lib/cem_win_spec/win_exec/winrm_exec.rb
 - sig/cem_win_spec.rbs
 homepage: https://github.com/hsnodgrass/cem_win_spec
 licenses:
@@ -152,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Write a short summary, because RubyGems requires one.

data/lib/cem_win_spec/remote_command.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'iap_tunnel'
-require_relative 'win_exec'
-
-module CemWinSpec
-  # Class for running a command on a remote Windows host
-  class RemoteCommand
-    attr_reader :title, :result
-
-    def initialize(title, iap_tunnel: nil, reuse_tunnel: true, winrm_opts: {}, &block)
-      @title = title
-      @iap_tunnel = iap_tunnel || IapTunnel.new
-      @reuse_tunnel = reuse_tunnel
-      @winrm_opts = winrm_opts
-      @block = block
-      @win_exec = WinExec.new('localhost', @iap_tunnel.port, winrm_opts: winrm_opts)
-      @result = nil
-    end
-
-    def ran?
-      !@result.nil?
-    end
-
-    def success?
-      @result.is_a? WinRM::Output
-    end
-
-    def run
-      puts "Running #{@title}"
-      @result = if @reuse_tunnel
-                  @iap_tunnel.start # ensure tunnel is running
-                  @block.call @win_exec
-                else
-                  @iap_tunnel.stop # ensure tunnel is stopped
-                  @iap_tunnel.with do # start tunnel for this block
-                    @block.call @win_exec
-                  end
-                end
-      @result
-    rescue StandardError => e
-      puts "Error running #{@title}: #{e}"
-      @result = e
-      raise @result
-    end
-  end
-end

data/lib/cem_win_spec/win_exec/base_exec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../logging'
-
-module CemWinSpec
-  module WinExec
-    class BaseExec
-      include CemWinSpec::Logging
-
-      attr_accessor :working_dir
-
-      def initialize(working_dir = nil)
-        @working_dir = working_dir
-      end
-
-      def available?
-        raise NotImplementedError
-      end
-
-      def exec(cmd, *_args, **_kwargs)
-        raise NotImplementedError
-      end
-
-      private
-
-      def cd_working_dir(cmd)
-        return cmd if working_dir.nil?
-
-        "cd #{working_dir}; #{cmd}"
-      end
-
-      def cmd_prefix_msg
-        prefix = 'Executing command'
-        working_dir.nil? ? "#{prefix}:\n" : "#{prefix} in #{working_dir}:\n"
-      end
-
-      def puts_cmd(cmd)
-        logger.debug "#{cmd_prefix_msg}#{cmd.split(%r{\n|\r\n|;\s*}).map { |c| "  #> #{c}" }.join("\n")}"
-      end
-    end
-  end
-end