cem_win_spec 0.1.2 → 0.1.4

data/lib/cem_win_spec/win_exec/exec.rb

@@ -0,0 +1,196 @@
+# 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
+        @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
+
+      # 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}"
+        result = run_with_tunnel { run_in_current_scope(*args, **kwargs) }
+        @result = Output.new(result)
+        return if @result.pending_threaded?
+
+        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
+    end
+  end
+end

data/lib/cem_win_spec/win_exec/factory.rb

@@ -0,0 +1,123 @@
+# 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)
+        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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'tty-spinner'
 require_relative 'cem_win_spec/logging'
 require_relative 'cem_win_spec/test_runner'
 
@@ -39,20 +38,19 @@ module CemWinSpec
     logger.debug "Created TestRunner: #{runner}"
     signal_handler(runner)
     logger.debug 'Set up signal handler'
-    spinner = TTY::Spinner.new(format: :classic, interval: 1, hide_cursor: true, clear: true)
     begin
-      sre_out = setup_remote_environment(runner, spinner)
+      sre_out = setup_remote_environment(runner)
       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, **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, **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, **options)
         check_output!(clean_fixture_cache_out, runner)
       else
         raise ArgumentError, "Unknown operation: #{operation}"
@@ -64,39 +62,38 @@ module CemWinSpec
     end
   end
 
-  def self.setup_remote_environment(runner, spinner)
+  def self.setup_remote_environment(runner)
     runner.enable_long_paths.run
     runner.enable_symlinks.run
     runner.enable_symlinks.run
     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, **opts)
     runner.setup_ruby(operation_timeout: 300,
                       receive_timeout: 310,
                       working_dir: module_dir,
                       reuse_tunnel: false,
-                      spinner: spinner).run
+                      **opts).run
   end
 
   # Runs RSpec tests
-  def self.run_spec(runner, module_dir, spinner)
-    #runner.rspec_prep(working_dir: module_dir, reuse_tunnel: false, spinner: spinner).run
+  def self.run_spec(runner, module_dir, **opts)
     runner.rspec_tests_parallel(operation_timeout: 300,
                                 receive_timeout: 310,
                                 working_dir: module_dir,
                                 ignore_exitcode: true,
                                 reuse_tunnel: false,
-                                spinner: spinner).run
+                                **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, **opts)
+    runner.clean_fixture_cache(working_dir: module_dir, **opts).run
   end
 
   def self.check_output!(output, runner = nil)