cem_win_spec 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 155b49bb4366a1b2fca4237d9da909e05093d907a5e7ff326f4d7a9c4e75f375
-  data.tar.gz: f374c915ab3afcf1636315c02b869fdd4690291070f8429418108d292a922cce
+  metadata.gz: 0f80bb9bd51e4ad8a8d005504e107a6c7761a4f8c63da2fe2df69f84e1afb1b4
+  data.tar.gz: 6eb10d5243db33711faa2b8f21914e05f3ce16cc6514ae6add15159f03c53266
 SHA512:
-  metadata.gz: 5709e80190d88d38826deae83c379a948d5e7de72202891db48b00521801ef56e9718a64c681b17ccc7eb82a275af72c955737fef9ee2ab62a8c1fbdccb0aa51
-  data.tar.gz: 3ec1282194e8a3afe8df90e3e13e7bd80428bf9d2a70f7d7b8fe6aea0437460bc3b35e8f7e19e8d3a55ded60076b489b078ba80b551b25aa917ccb9cdc0526d0
+  metadata.gz: 3203c1ce68eb0c392c3968b82cf80066023545b1a4522d415b1f199538bdfd7cef34c4b2e4c8bd154ddec5e95fe5fe1f5b88652aeac81f2650f8a1b27bf3a8f4
+  data.tar.gz: 8ef99fac173500c73992db6f059a704674f862bf17563a3f3aff05507eb01e715a829ea822bf6c1f3845bdae9640f90f8d178247c57ad28eb402250fc8046b48

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_win_spec (0.1.5)
+    cem_win_spec (0.1.7)
       parallel_tests (~> 3.4)
       puppet_forge (~> 4.1)
       winrm (~> 2.3)
@@ -11,17 +11,18 @@ GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    bigdecimal (3.1.6)
     builder (3.2.4)
     coderay (1.1.3)
     diff-lcs (1.5.0)
     erubi (1.12.0)
-    faraday (2.7.10)
-      faraday-net_http (>= 2.0, < 3.1)
-      ruby2_keywords (>= 0.0.4)
+    faraday (2.9.0)
+      faraday-net_http (>= 2.0, < 3.2)
     faraday-follow_redirects (0.3.0)
       faraday (>= 1, < 3)
-    faraday-net_http (3.0.2)
-    ffi (1.15.5)
+    faraday-net_http (3.1.0)
+      net-http
+    ffi (1.16.3)
     gssapi (1.3.1)
       ffi (>= 1.0.1)
     gyoku (1.4.0)
@@ -35,7 +36,10 @@ GEM
     method_source (1.0.0)
     minitar (0.9)
     multi_json (1.15.0)
-    nori (2.6.0)
+    net-http (0.4.1)
+      uri
+    nori (2.7.0)
+      bigdecimal
     parallel (1.22.1)
     parallel_tests (3.13.0)
       parallel
@@ -78,11 +82,11 @@ GEM
     rubocop-ast (1.24.1)
       parser (>= 3.1.1.0)
     ruby-progressbar (1.11.0)
-    ruby2_keywords (0.0.5)
     rubyntlm (0.6.3)
     rubyzip (2.3.2)
     semantic_puppet (1.1.0)
     unicode-display_width (2.1.0)
+    uri (0.13.0)
     winrm (2.3.6)
       builder (>= 2.1.2)
       erubi (~> 1.8)

data/lib/cem_win_spec/fixture_cache.rb

@@ -8,6 +8,8 @@ require 'puppet_forge'
 require 'yaml'
 
 module CemWinSpec
+  class FixtureCacheError < StandardError; end
+
   # Class for managing cached fixtures
   # Fixture caching is used to speed up test runs by reusing the same
   # Puppet modules between test runs instead of downloading them each time.
@@ -24,11 +26,10 @@ module CemWinSpec
     attr_reader :cache_dir, :cache_entries
 
     def initialize
-      raise 'FixtureCache must be ran on Windows' unless Gem.win_platform?
-
+      validate_platform!
       @cache_dir = CACHE_DIR
       @cache_entries = setup_and_load_cache
-      @entries_digest = Digest::SHA256.hexdigest(@cache_entries.to_s)
+      @entries_digest = hexdigest(@cache_entries.to_s)
       @dependencies = dependencies_from_metadata
       setup!
     end
@@ -43,6 +44,8 @@ module CemWinSpec
         puts "Downloading #{name} #{data[:version]}..."
         download_and_cache(name, data[:release_slug], data[:checksum])
       end
+    rescue StandardError => e
+      handle_error(e, 'Failed to setup fixture cache')
     ensure
       save_cache_entries
     end
@@ -52,16 +55,37 @@ module CemWinSpec
       raise "Directory #{fixtures_dir} does not exist" unless File.directory?(fixtures_dir)
 
       @cache_entries.each do |_, path|
-        ::FileUtils.cp_r(path, fixtures_dir)
-        interim_mod_path = File.join(fixtures_dir, File.basename(path))
         final_mod_path = File.join(fixtures_dir, File.basename(path).split('-').last)
-        ::FileUtils.mv(interim_mod_path, final_mod_path)
-        puts "Copied #{File.basename(path)} to #{final_mod_path}"
+        ::FileUtils.remove_entry_secure(final_mod_path) if File.exist?(final_mod_path)
+        ::FileUtils.cp_r(path, final_mod_path)
+        puts "Copied #{path} to #{final_mod_path}"
       end
+    rescue StandardError => e
+      handle_error(e, "Failed to copy fixtures to #{fixtures_dir}")
     end
 
     private
 
+    def validate_platform!
+      return if Gem.win_platform?
+
+      $stderr.puts 'ERROR: FixtureCache must run on Windows'
+      raise FixtureCacheError, 'FixtureCache must run on Windows'
+    end
+
+    def hexdigest(str)
+      Digest(:SHA256).hexdigest(str)
+    end
+
+    def handle_error(e, msg = 'Fixture cache error')
+      $stderr.puts "ERROR: #{msg}: #{e}"
+      raise e if e.is_a?(FixtureCacheError)
+
+      new_err = FixtureCacheError.new("#{msg}: #{e}")
+      new_err.set_backtrace(e.backtrace)
+      raise new_err
+    end
+
     def dependencies_from_metadata
       raise "File metadata.json not found in current directory #{Dir.pwd}" unless File.exist?('metadata.json')
 
@@ -81,6 +105,8 @@ module CemWinSpec
           release_slug: latest_valid_release.slug,
         }
       end
+    rescue StandardError => e
+      handle_error(e, 'Failed to get dependencies from metadata.json')
     end
 
     def dep_version_req_satisfied?(version_req, version)
@@ -88,6 +114,8 @@ module CemWinSpec
       raise "Invalid version requirement #{version_req}" unless reqs.to_a.length > 1
 
       reqs.to_a[1..-1].all? { |req| version_req_satisfied?(req, version) }
+    rescue StandardError => e
+      handle_error(e, 'Failed checking version requirement satisfaction')
     end
 
     def version_req_satisfied?(version_req, version)
@@ -95,7 +123,7 @@ module CemWinSpec
     end
 
     def module_checksum(name, version_req, version)
-      Digest::SHA256.hexdigest("#{name}#{version_req}#{version}")
+      hexdigest("#{name}#{version_req}#{version}")
     end
 
     def manifest
@@ -114,6 +142,8 @@ module CemWinSpec
       end
       puts "Loading cache manifest #{manifest}..."
       YAML.load_file(manifest)
+    rescue StandardError => e
+      handle_error(e, 'Failed to setup and load cache')
     end
 
     def cached?(checksum)
@@ -132,13 +162,17 @@ module CemWinSpec
                                    File.join(module_cache_dir, 'temp'))
       cache_entries[checksum] = File.join(module_cache_dir, name)
       puts "Downloaded #{release_slug} to #{File.join(module_cache_dir, name)}"
+    rescue StandardError => e
+      handle_error(e, "Failed to download and cache #{name} with slug #{release_slug} and checksum #{checksum}")
     end
 
     def save_cache_entries
-      return if @entries_digest == Digest::SHA256.hexdigest(cache_entries.to_s)
+      return if @entries_digest == hexdigest(cache_entries.to_s)
 
       File.write(manifest, cache_entries.to_yaml)
       puts "Saved cache manifest #{manifest}"
+    rescue StandardError => e
+      handle_error(e, "Failed to save cache manifest #{manifest}")
     end
   end
 end

data/lib/cem_win_spec/module_archive_builder.rb

@@ -8,50 +8,37 @@ module CemWinSpec
   class ModuleArchiveBuilder
     include CemWinSpec::Logging
 
-    FILE_ALLOWLIST = %w[
-      data
-      files
-      lib
-      manifests
-      plans
-      spec
-      tasks
-      types
-      .fixtures.yml
-      .gitignore
-      .rspec
-      .rubocop.yml
-      .yardopts
-      hiera.yaml
-      Gemfile
-      metadata.json
-      Rakefile
+    FILE_EXCLUDELIST = %w[
+      .git/**/*
+      data/benchmarks/**/*
+      dev/**/*
+      spec/fixtures/modules/*
+      pkg/**/*
+      Gemfile.lock
     ].freeze
 
-    attr_reader :module_dir, :allowlist, :tempdir, :archive
+    attr_reader :module_dir, :excludelist, :tempdir, :archive
 
-    def initialize(module_dir = Dir.pwd, allowlist: FILE_ALLOWLIST)
+    def initialize(module_dir = Dir.pwd, excludelist: FILE_EXCLUDELIST)
       @module_dir = module_dir
       @module_name = File.basename(module_dir)
-      @allowlist = allowlist
+      @excludelist = excludelist
     end
 
     alias path archive
 
-    def build
+    def build(remove_when_complete: true)
       create_tempdir
       copy_module_to_tempdir
       remove_unwanted_files
       create_archive
       if block_given?
         begin
-          yield archive
-        ensure
-          FileUtils.rm_rf(archive) if archive && File.exist?(archive)
+          yield File.join(tempdir, archive)
         end
       end
     ensure
-      FileUtils.rm_rf(tempdir) if tempdir && File.exist?(tempdir)
+      FileUtils.rm_rf(tempdir) if remove_when_complete && tempdir && File.exist?(tempdir)
     end
 
     private
@@ -62,22 +49,30 @@ module CemWinSpec
     end
 
     def copy_module_to_tempdir
-      FileUtils.cp_r(module_dir, tempdir)
+      FileUtils.cp_r(module_dir, tempdir, preserve: false)
       logger.debug "Copied #{module_dir} to #{tempdir}"
       @temp_module_dir = File.join(tempdir, @module_name)
     end
 
-    def remove_unwanted_files
-      to_remove = Dir.glob("*", File::FNM_DOTMATCH, base: @temp_module_dir).reject { |f| allowlist.include?(f) || %w[. ..].include?(f) }
-      to_remove.each do |file|
-        FileUtils.rm_rf(File.join(@temp_module_dir, file))
-        logger.debug "Removed #{file} from #{@temp_module_dir}"
+    def unwanted_files
+      unwanted = []
+      Dir.glob('**/*', File::FNM_DOTMATCH, base: @temp_module_dir) do |f|
+        next if %w[. ..].include?(f)
+
+        unwanted << File.join(@temp_module_dir, f) if excludelist.any? { |e| File.fnmatch?(e, f, File::FNM_DOTMATCH) }
       end
+      unwanted
+    end
+
+    def remove_unwanted_files
+      FileUtils.rm_rf(unwanted_files, verbose: (logger.level.first <= Logger::DEBUG))
     end
 
     def create_archive
       @archive = "#{@module_name}.tar.gz"
-      `tar -czf #{archive} -C #{tempdir} #{@module_name}`
+      Dir.chdir(tempdir) do
+        `COPYFILE_DISABLE=1 tar -czf #{archive} --no-acls --no-xattrs #{@module_name}`
+      end
       logger.info "Created module archive #{archive}"
     end
   end

data/lib/cem_win_spec/rake_tasks.rb

@@ -81,7 +81,7 @@ namespace 'cem_win_spec' do
   task :prep do
     puts 'Preparing spec data...'
     data_fix = cem_win_spec_base_path_in_fixtures(cem_win_spec_data_dir)
-    if File.directory?(data_fix)
+    if Dir.exist?(data_fix)
       puts "Removing old #{data_fix} directory..."
       ::FileUtils.remove_entry_secure(data_fix)
     end
@@ -91,16 +91,23 @@ namespace 'cem_win_spec' do
       raise 'Spec data copy failed!'
     end
     hiera_fix = cem_win_spec_base_path_in_fixtures(cem_win_spec_hiera_conf)
+    if File.file?(hiera_fix)
+      puts "Removing old #{hiera_fix} file..."
+      ::FileUtils.remove_entry_secure(hiera_fix)
+    end
     puts "Copying Hiera config to #{hiera_fix}..."
     ::FileUtils.cp(cem_win_spec_hiera_conf, hiera_fix)
-    unless File.exist?(hiera_fix)
-      raise 'Hiera config copy failed!'
-    end
+    raise 'Hiera config copy failed!' unless File.exist?(hiera_fix)
+
     puts 'Spec data prepared successfully'
-    puts 'Preparing module fixtures...'
-    mod_fix = cem_win_spec_base_path_in_fixtures('modules')
+    puts 'Setting up module fixture cache...'
     cache = CemWinSpec::FixtureCache.new
+    puts 'Copying module fixtures to spec fixtures directory...'
+    mod_fix = cem_win_spec_base_path_in_fixtures('modules')
     cache.copy_fixtures_to(mod_fix)
+    puts 'Removing old module symlink...'
+    link_path = File.join(mod_fix, 'cem_windows')
+    ::FileUtils.remove_entry_secure(link_path) if File.exist?(link_path)
     puts 'Module fixtures prepared successfully'
   end
 
@@ -108,9 +115,10 @@ namespace 'cem_win_spec' do
   task :parallel_spec_standalone do
     spec_files = Rake::FileList[cem_win_spec_pattern]
     pargs = ['--type', 'rspec']
-    pargs << '--trace' if cem_win_spec_trace
+    pargs << '--verbose' if cem_win_spec_trace
     rspec_args = ['--']
     rspec_args << '--fail-fast' if cem_win_spec_fail_fast
+    rspec_args << '--backtrace' if cem_win_spec_trace
     rspec_args.concat(['--format', cem_win_spec_format])
     pargs.concat(rspec_args)
     pargs << '--'

data/lib/cem_win_spec/test_runner.rb

@@ -21,19 +21,11 @@ module CemWinSpec
       @rspec_cmds = RspecTestCmds.new
       @iap_tunnel = IapTunnel.new
       @win_exec_factory = CemWinSpec::WinExec::Factory.new(@iap_tunnel, @module_archive_builder, @rspec_cmds)
+      @retry = false
     end
 
-    def run_all
-      check_connectivity.run
-      enable_long_paths.run
-      enable_symlinks.run
-      @working_dir = create_working_dir.run
-      upload_module.run(@working_dir)
-      setup_ruby.run(@working_dir)
-      rspec_tests_parallel.run(@working_dir)
-    ensure
-      clean_up(@working_dir)
-      @iap_tunnel.stop if @iap_tunnel.running?
+    def retry?
+      @retry
     end
 
     def enable_long_paths(**opts)
@@ -68,7 +60,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_run("tar -xzf #{module_dir}.tar.gz -C #{remote_working_dir}")
+        remote_run("tar -C #{remote_working_dir} -xzf #{module_dir}.tar.gz")
         logger.debug "Module extracted to #{module_dir}"
         module_dir
       end
@@ -78,6 +70,8 @@ module CemWinSpec
       @setup_ruby ||= new_command('Set up ruby', **opts) do
         remote_run(
           [
+            'if (Test-Path .bundle) { Remove-Item -Recurse -Force .bundle }',
+            'if (Test-Path Gemfile.lock) { Remove-Item -Force Gemfile.lock }',
             'bundle config disable_platform_warnings true',
             'bundle config set --local without \'local_development\'',
             'bundle install',
@@ -104,10 +98,10 @@ module CemWinSpec
       end
     end
 
-    def clean_up
+    def clean_up(working_dir)
       @clean_up ||= new_command('Cleanup') do |working_dir|
         if remote_available?
-          remote_run(cleanup_cmd, quiet: true)
+          remote_run(cleanup_cmd, working_dir, quiet: true)
         else
           logger.warn 'Cleanup not available'
         end
@@ -120,6 +114,10 @@ module CemWinSpec
       end
     end
 
+    def inspect
+      "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+    end
+
     private
 
     def title_sym(title)

data/lib/cem_win_spec/version.rb

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

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

@@ -12,6 +12,10 @@ module CemWinSpec
         '7' => '278',
         '8' => '322',
       }.freeze
+      TOOL_DIR_BY_RUBY_VER = {
+        '278' => 'C:/tools/ruby/2.7.8',
+        '322' => 'C:/tools/ruby/3.2.2',
+      }.freeze
 
       attr_accessor :working_dir, :env_vars, :puppet_version
 
@@ -80,12 +84,17 @@ module CemWinSpec
         logger.debug "Executing command:\n#{cmd.split(%r{\n|\r\n|;\s*}).map { |c| "  #> #{c}" }.join("\n")}"
       end
 
+      # Commands that, when ran, will change the ruby version. This will also set the local bundle config path
       def change_ruby_version_cmd
-        "uru #{ruby_version}"
+        [
+          "uru #{ruby_version}",
+          '$env:GEM_HOME = "$(ruby -e "puts Gem.dir")"',
+          'bundle config set --local path "$env:GEM_HOME"',
+        ].join(COMMAND_SEPARATOR)
       end
 
       def set_env_var_cmd(key, value)
-        "set #{key}=\"#{value}\""
+        "$env:#{key} = \"#{value}\""
       end
 
       def change_working_dir_cmd(dir)

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

@@ -29,8 +29,8 @@ module CemWinSpec
         begin
           shell = conn.shell(:powershell)
           output = shell.run(command(cmd)) do |stdout, stderr|
-            logger << stdout unless stdout.nil? || stdout.empty?
-            logger << stderr unless stderr.nil? || stderr.empty?
+            logger << stdout if stdout
+            logger << stderr if stderr
           end
         rescue WinRM::WinRMAuthorizationError => e
           @available = false

data/lib/cem_win_spec/win_exec/exec.rb

@@ -36,7 +36,7 @@ module CemWinSpec
 
       def add_local_cmd(value)
         raise ArgumentError, 'local_exec must implement the #run method' unless value.respond_to?(:run)
-        
+
         @local_cmd = value
       end
 
@@ -88,7 +88,7 @@ module CemWinSpec
         @ignore_exitcode = value
       end
       alias ignore_exitcode? ignore_exitcode
-  
+
       def success?
         @result.success? if @result.is_a?(Output)
 
@@ -146,11 +146,13 @@ module CemWinSpec
           super
         end
       end
-  
+
       def run(*args, **kwargs)
         validate_instance_variables
         logger.info "Running #{@title}"
         result = run_with_tunnel { run_in_current_scope(*args, **kwargs) }
+        logger.debug "Command stdout: #{result.stdout}" if result.respond_to?(:stdout)
+        logger.debug "Command stderr: #{result.stderr}" if result.respond_to?(:stderr)
         @result = Output.new(result)
         return if @result.pending_threaded?
 

data/lib/cem_win_spec/win_exec/output.rb

@@ -53,19 +53,31 @@ module CemWinSpec
         end
         out_array.compact!
         return if out_array.empty?
-        
+
         logger.info "#{stream_name.to_s.upcase}:\n#{out_array.join("\n")}"
       end
 
+      def to_s
+        return '' if @raw_output.nil?
+
+        format_output_string(@raw_output.to_s)
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} exitcode=#{exitcode.inspect} stdout=#{stdout.inspect} stderr=#{stderr.inspect}>"
+      end
+
       private
 
       def format_output_string(str)
         # Cut the number of spaces in half, replace tabs with double spaces
         str.gsub!(/\s\s/, ' ')
         str.gsub!(/\t/, '  ')
-        return "#{@line_prefix}#{str}" if str.length <= 115
+        return "#{@line_prefix}#{str}" if str.length <= 180
 
-        str.scan(/.{1,115}/).map { |s| "#{@line_prefix}#{s}" }.join("\n")
+        str.scan(/.{1,180}/).map { |s| "#{@line_prefix}#{s}" }.instance_eval { |a|
+          [a.first] + a.drop(1).map { |s| "  #{s}" }
+        }.join("\n")
       end
 
       def set_vars_from_output(out)

data/lib/cem_win_spec.rb

@@ -40,23 +40,22 @@ module CemWinSpec
     logger.debug 'Set up signal handler'
     begin
       sre_out = setup_remote_environment(runner)
-      check_output!(sre_out, runner)
-      module_dir = sre_out.stdout.chomp
+      working_dir = sre_out.stdout.chomp
+      logger.debug "Working dir: #{working_dir}"
+      upload_out = upload_module(runner, working_dir)
+      module_dir = upload_out.stdout.chomp
       logger.debug "Module dir: #{module_dir}"
-      srr_out = setup_remote_ruby(runner, module_dir, **options)
-      check_output!(srr_out, runner)
+      setup_remote_ruby(runner, module_dir, **options)
       case operation
       when :spec
-        spec_out = run_spec(runner, module_dir, **options)
-        check_output!(spec_out, runner)
+        run_spec(runner, module_dir, **options)
       when :clean_fixture_cache
-        clean_fixture_cache_out = clean_fixture_cache(runner, module_dir, **options)
-        check_output!(clean_fixture_cache_out, runner)
+        clean_fixture_cache(runner, module_dir, **options)
       else
         raise ArgumentError, "Unknown operation: #{operation}"
       end
     rescue StandardError => e
-      if operation == :spec
+      if operation == :spec && runner.retry?
         begin
           logger.warn "Error running spec: #{e.message}"
           logger.debug e.backtrace.join("\n")
@@ -67,6 +66,9 @@ module CemWinSpec
       else
         handle_run_error(e)
       end
+    ensure
+      runner&.clean_up(working_dir) if working_dir
+      runner&.iap_tunnel&.stop(wait: false, log: false)
     end
   end
 
@@ -78,44 +80,60 @@ module CemWinSpec
 
   def self.retry_spec_on_error(runner, module_dir, **options)
     logger.info 'Cleaning cache and trying again...'
-    clean_fixture_cache_out = clean_fixture_cache(runner, module_dir, **options)
-    check_output!(clean_fixture_cache_out, runner)
-    spec_out = run_spec(runner, module_dir, **options)
-    check_output!(spec_out, runner)
+    validate_output do
+      clean_fixture_cache(runner, module_dir, **options)
+    end
+    validate_output do
+      run_spec(runner, module_dir, **options)
+    end
   end
 
   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(operation_timeout: 300, receive_timeout: 310, working_dir: working_dir).run
+    validate_output do
+      runner.enable_long_paths.run
+    end
+    validate_output do
+      runner.enable_symlinks.run
+    end
+    validate_output do
+      runner.create_working_dir.run
+    end
+  end
+
+  def self.upload_module(runner, working_dir)
+    validate_output do
+      runner.upload_module(operation_timeout: 300, receive_timeout: 310, working_dir: working_dir).run
+    end
   end
 
   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,
-                      **opts).run
+    validate_output do
+      runner.setup_ruby(operation_timeout: 300,
+                        receive_timeout: 310,
+                        working_dir: module_dir,
+                        reuse_tunnel: false,
+                        **opts).run
+    end
   end
 
   # Runs RSpec tests
   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,
-                                **opts).run
+    output = validate_output(validation_method: :inspect) do
+      runner.rspec_tests_parallel(operation_timeout: 300,
+                                  receive_timeout: 310,
+                                  working_dir: module_dir,
+                                  ignore_exitcode: true,
+                                  reuse_tunnel: false,
+                                  **opts).run
+    end
   end
 
   # Clean the remote fixture cache
   # @param options [Hash] Options for the test runner
   def self.clean_fixture_cache(runner, module_dir, **opts)
-    runner.clean_fixture_cache(working_dir: module_dir, **opts).run
+    validate_output do
+      runner.clean_fixture_cache(working_dir: module_dir, **opts).run
+    end
   end
 
   def self.check_output!(output, runner = nil)
@@ -124,4 +142,30 @@ module CemWinSpec
       raise "Command failed with exit code #{output.exitcode}"
     end
   end
+
+  class CemWinSpecValidationError < StandardError; end
+
+  def self.validate_output(*args, validation_method: :success?, no_output_strat: :debug, **kwargs)
+    raise ArgumentError, 'Block required' unless block_given?
+
+    output = yield *args, **kwargs
+    unless output
+      case no_output_strat
+      when :raise
+        raise 'No output'
+      when :warn
+        logger.warn 'No output'
+      when :debug
+        logger.debug 'No output'
+      else
+        # Do nothing
+      end
+      return false
+    end
+
+    unless output.send(validation_method)
+      raise CemWinSpecValidationError, "Output validation \"#{validation_method}\" failed: #{output}"
+    end
+    output
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cem_win_spec
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Heston Snodgrass
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-21 00:00:00.000000000 Z
+date: 2024-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: winrm
@@ -139,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Write a short summary, because RubyGems requires one.