cem_win_spec 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e203035d39f85443211c2780752bfe4ac3bcbdb00f2609e314ec2e9c590262a
-  data.tar.gz: fdf8d060009aec0fe839afa4fdba545e812c4933fb4fbc9f21dfa79a775808bf
+  metadata.gz: cdb91d3bd9c4220238d0712938226a34f036c4313370f0ac70b818402d67051d
+  data.tar.gz: 6e1b4a03b910513b5d4e985f5643394834f0ff38e7af9c03ffebe24a179d1f61
 SHA512:
-  metadata.gz: bcba5218950ecc0e48a696c49e96407dccd5d097365570e8a203bf204281a339a4b1f7f2e70bb7f3121dbdcd67639112cae189d688b7ed57e749b906bec0020e
-  data.tar.gz: 0a58f7fad80e1fecdbd5669f102a661bae70bb51beeb70fe378820436b8696eb9cb636024a6cac6957cc7ea4899c0d5f4c9c02d8d21a2ed14cee4de513a7439d
+  metadata.gz: d36cc7f04c91d80fd494caecbe1ee33b39a71d3cde95cf71f4381ba12c232f0f4ed02b91886a89a9e4d2253d1b8ca9bc58bb8348e69d8eda97c7e5d5da22399c
+  data.tar.gz: c3fc479c502495358843257577391242f7c7003abee9fcb73e7dfa2e456adcd9bbbd448b864b9df347096d519c6ca4ca9ce6c9a7be71582acca448710bb88807

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_win_spec (0.1.0)
+    cem_win_spec (0.1.1)
       parallel_tests (~> 3.4)
       puppet_forge (~> 4.1)
       tty-spinner (~> 0.9)

data/README.md

@@ -1,8 +1,6 @@
 # CemWinSpec
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/cem_win_spec`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+cem_win_spec is a gem that provides CLI for running CEM RSpec test on a remote Windows machine.
 
 ## Installation
 
@@ -16,18 +14,65 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+CemWinSpec requires that you have [gcloud](https://cloud.google.com/sdk/gcloud) installed and configured to connect to the GCP instance that you want to run the tests on.
+
+The gem provides a CLI that can be used to run CEM RSpec tests on a remote Windows machine. The CLI help menu can be viewed by running:
+
+    $ cem-win-spec --help
+    Usage: cem-win-spec [options]
+        -v, --version                    Print version and exit
+        -o, --operation [OPERATION]      Operation to perform (spec, clean_fixture_cache)
+        -q, --quiet                      Suppress output
+        -d, --debug                      Enable debug output on the console
+        -l, --log-level [LEVEL]          Set log level (debug, info, warn, error, fatal)
+        -L, --log-file [FILE]            Log output to file
+        -f, --log-format [FORMAT]        Set log format(file, text, json, github_action
+        -h, --help                       Print this help
+
+The `operation` option can be used to specify the operation to perform. The CLI supports the following operations:
+
+    spec - Run the RSpec tests on the remote Windows machine (default)
+    clean_fixture_cache - Clean the RSpec fixture cache on the remote Windows machine
+
+The `quiet` option can be used to suppress all console output. This option can be used in conjunction with the `log-file` option to suppress console output and only log to a file.
+
+The `debug` option only affects the console output and does not affect the log file output.
+
+The `log-level` option can be used to set the log level for the log file output. The default log level is `debug`.
+
+The `log-file` option can be used to set the log file path. If this is not set, no log file will be created.
+
+The `log-format` option can be used to set the log format. The default log format is `text` for the console and `file` for the log file. The `github_action` format is designed to be used with GitHub Actions. Setting this affects both the console and log file output.
+
+### Configuration
+
+CemWinSpec takes it's configuration from environment variables. The following environment variables are required:
+
+- `GCP_INSTANCE_NAME` - The name of the GCP Windows instance to run the tests on
+- `WINRM_USERNAME` - The username to use when connecting to the GCP instance
+- `WINRM_PASSWORD` - The password to use when connecting to the GCP instance
+
+The following environment variables may be required if they cannot be determined from gcloud:
+
+- `GCP_PROJECT_ID` - The GCP project ID that the instance is in
+- `GCP_ZONE` - The GCP zone that the instance is in
+
+The following environment variables are optional:
 
-## Development
+- `CEM_WIN_SPEC_PATTERN` - The pattern to use when running the tests. Defaults to `spec/{classes,defines,functions,unit}/**/*_spec.rb`
+- `CEM_WIN_SPEC_FAIL_FAST` - If set to true, the tests will stop running after the first failure. Defaults to `false`
+- `CEM_WIN_SPEC_TRACE` - If set to true, Rake will output a full backtrace for any halting errors. Defaults to `false`
+- `CEM_WIN_SPEC_FORMAT` - The RSpec output format to use when running the tests. Defaults to `progress`
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+The following environment variables have an effect, but should not be set manually:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+- `CI` - If set, the tests will run in CI mode which changes the logging output to be more suitable for GitHub Actions
+- `GITHUB_ACTIONS` - If set, the tests will run in CI mode which changes the logging output to be more suitable for GitHub Actions
 
-## Contributing
+### Adding to module Rakefile
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cem_win_spec.
+The following line must be added to the `Rakefile` in the CEM Windows repository:
 
-## License
+    require 'cem_win_spec/rake_tasks' if Bundler.rubygems.find_name('cem_win_spec').any?
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+This will add the `cem_win_spec` task namespace to the Rakefile, along with the tasks `run`, `prep`, and `parallel_spec`. The tasks are used by `cem_win_spec` to run the tests on the remote Windows machine and should not be used directly.

data/exe/cem-win-spec

@@ -18,6 +18,15 @@ parser = OptionParser.new do |opts|
     exit 0
   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}"
+      puts opts
+      exit 1
+    end
+    options[:operation] = operation.to_sym
+  end
+
   opts.on('-q', '--quiet', 'Suppress output') do
     options[:quiet] = true
   end
@@ -26,10 +35,6 @@ parser = OptionParser.new do |opts|
     options[:debug] = true
   end
 
-  opts.on('-V', '--verbose', 'Enable verbose output on the console') do
-    options[:verbose] = true
-  end
-
   opts.on('-l', '--log-level [LEVEL]', 'Set log level (debug, info, warn, error, fatal)') do |level|
     options[:log_level] = level
   end
@@ -49,4 +54,5 @@ parser = OptionParser.new do |opts|
 end
 parser.parse!
 
-CemWinSpec.run_tests(options)
+operation = options[:operation] || :spec
+CemWinSpec.run(operation, options)

data/lib/cem_win_spec/fixture_cache.rb

@@ -13,30 +13,32 @@ module CemWinSpec
   # Puppet modules between test runs instead of downloading them each time.
   # The cache works by creating a YAML file that maps module names and
   class FixtureCache
+    CACHE_DIR = 'C:/cem_win_spec'
     CACHE_MANIFEST = 'cache_manifest.yaml'
 
+    def self.clean!
+      ::FileUtils.rm_rf(CACHE_DIR) if File.directory?(CACHE_DIR)
+      puts "Deleted fixture cache #{CACHE_DIR}"
+    end
+
     attr_reader :cache_dir, :cache_entries
 
-    def initialize(cache_dir = 'C:\\ProgramData\\cem_win_spec')
+    def initialize
       raise 'FixtureCache must be ran on Windows' unless Gem.win_platform?
 
-      @cache_dir = cache_dir
+      @cache_dir = CACHE_DIR
       @cache_entries = setup_and_load_cache
+      @entries_digest = Digest::SHA256.hexdigest(@cache_entries.to_s)
       @dependencies = dependencies_from_metadata
       setup!
     end
 
-    def copy_fixtures_to(fixtures_dir)
-      @cache_entries.each do |_, path|
-        FileUtils.cp_r(path, fixtures_dir)
-      end
-    end
-
-    private
-
     def setup!
       @dependencies.each do |name, data|
-        next if cached?(data[:checksum])
+        if cached?(data[:checksum])
+          puts "Using cached #{name} #{data[:version]}"
+          next
+        end
 
         puts "Downloading #{name} #{data[:version]}..."
         download_and_cache(name, data[:release_slug], data[:checksum])
@@ -45,6 +47,21 @@ module CemWinSpec
       save_cache_entries
     end
 
+    def copy_fixtures_to(fixtures_dir, make_fixtures_dir: true)
+      ::FileUtils.mkdir_p(fixtures_dir) if make_fixtures_dir
+      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}"
+      end
+    end
+
+    private
+
     def dependencies_from_metadata
       raise "File metadata.json not found in current directory #{Dir.pwd}" unless File.exist?('metadata.json')
 
@@ -93,7 +110,9 @@ module CemWinSpec
       unless File.exist?(manifest)
         puts "Creating cache manifest #{manifest}..."
         File.write(manifest, {}.to_yaml)
+        `attrib -s -h -r #{cache_dir.gsub('/', '\\')}\\*.* /s`
       end
+      puts "Loading cache manifest #{manifest}..."
       YAML.load_file(manifest)
     end
 
@@ -101,7 +120,7 @@ module CemWinSpec
       cache_entries.key?(checksum)
     end
 
-    def download_and_cache(release_slug, checksum)
+    def download_and_cache(name, release_slug, checksum)
       release = PuppetForge::Release.find(release_slug)
       module_cache_dir = File.join(cache_dir, checksum)
       ::FileUtils.mkdir_p(File.join(cache_dir, checksum))
@@ -112,10 +131,14 @@ module CemWinSpec
                                    File.join(module_cache_dir, name),
                                    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)}"
     end
 
     def save_cache_entries
+      return if @entries_digest == Digest::SHA256.hexdigest(cache_entries.to_s)
+
       File.write(manifest, cache_entries.to_yaml)
+      puts "Saved cache manifest #{manifest}"
     end
   end
 end

data/lib/cem_win_spec/logging.rb

@@ -76,7 +76,10 @@ module CemWinSpec
       # create a new one.
       # @return [Logger]
       def logger
-        raise 'Logger not set up! Call CemWinSpec::Logging.log_setup! first.' unless @logger
+        unless @logger
+          warn 'Logger not set up! Setting up default logger.'
+          log_setup!
+        end
 
         @logger
       end

data/lib/cem_win_spec/rake_tasks.rb

@@ -1,138 +1,126 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'rake'
-require 'rake/file_list'
-require 'rake/tasklib'
 require 'parallel_tests'
-require_relative 'fixture_cache'
-
-# Provides custom rake tasks to run tests on a remote Windows host.
-# Add the following to your Rakefile to use:
-#   require 'cem_win_spec/rake_tasks'
-#   CemWinSpecRakeTasks::All.new
-module CemWinSpecRakeTasks
-  # Class for defining all custom rake tasks
-  class All
-    def initialize(**opts)
-      @namespace = opts[:namespace] || :cem_win_spec
-      @data_dir = opts[:data_dir]
-      @hiera_conf = opts[:hiera_conf]
-      @pattern = opts[:pattern]
-      @fail_fast = opts[:fail_fast]
-      @format = opts[:format]
-      define_tasks
-    end
+require 'cem_win_spec/fixture_cache'
 
-    private
+def cem_win_spec_work_dir
+  w_dir = Dir.pwd
+  unless File.exist?(File.join(w_dir, 'metadata.json'))
+    raise "Current working directory is not a module root directory! dir: #{dir}"
+  end
+  w_dir
+end
 
-    def define_tasks
-      define_prep_task
-      define_test_task
-    end
+def cem_win_spec_dir
+  s_dir = File.join(cem_win_spec_work_dir, 'spec')
+  unless File.directory?(s_dir)
+    raise "Spec directory '#{s_dir}' does not exist!"
+  end
+  s_dir
+end
 
-    def define_prep_task
-      prep_task = Prep.new(@namespace)
-      prep_task.data_dir = @data_dir if @data_dir
-      prep_task.hiera_conf = @hiera_conf if @hiera_conf
-      prep_task.define_task
-    end
+def cem_win_spec_fixtures_dir
+  f_dir = File.join(cem_win_spec_dir, 'fixtures')
+  ::FileUtils.mkdir_p(f_dir) unless File.directory?(f_dir)
+  f_dir
+end
 
-    def define_test_task
-      test_task = Test.new(@namespace)
-      test_task.pattern = @pattern if @pattern
-      test_task.fail_fast = @fail_fast if @fail_fast
-      test_task.format = @format if @format
-      test_task.define_task
-    end
+def cem_win_spec_base_path_in_fixtures(path)
+  base = File.basename(path)
+  File.join(cem_win_spec_fixtures_dir, base)
+end
+
+def cem_win_spec_data_dir
+  d_dir = File.join(cem_win_spec_work_dir, 'data')
+  unless File.directory?(d_dir)
+    raise "Data directory '#{d_dir}' does not exist!"
   end
+  d_dir
+end
 
-  # Class for defining the cem_win_spec:prep task
-  class Prep
-    attr_accessor :data_dir, :hiera_conf
+def cem_win_spec_hiera_conf
+  h_file = File.join(cem_win_spec_work_dir, 'hiera.yaml')
+  unless File.file?(h_file)
+    raise "Hiera config file '#{h_file}' does not exist!"
+  end
+  h_file
+end
 
-    def initialize(namespace = :cem_win_spec)
-      @namespace = namespace
-      @data_dir = 'data'
-      @hiera_conf = 'hiera.yaml'
-    end
+def cem_win_spec_pattern
+  ENV['CEM_WIN_SPEC_PATTERN'] || 'spec/{classes,defines,functions,unit}/**/*_spec.rb'
+end
 
-    def define_task
-      namespace @namespace do
-        desc 'Prepare spec data'
-        task :prep do
-          if Gem.win_platform?
-            prep_data
-            prep_modules
-          else
-            puts 'Not on Windows, skipping prep'
-          end
-        end
-      end
-    end
-    
-    private
+def cem_win_spec_fail_fast
+  ff_var = ENV['CEM_WIN_SPEC_FAIL_FAST'] || 'false'
+  (ff_var).match?(/^(true|t|yes|y|1)$/i)
+end
 
-    def fixtures(rel_path = nil)
-      fixtures_dir = File.expand_path(File.join('spec', 'fixtures'))
-      rel_path ? File.join(fixtures_dir, rel_path) : fixtures_dir
-    end
+def cem_win_spec_trace
+  t_var = ENV['CEM_WIN_SPEC_TRACE'] || 'false'
+  (t_var).match?(/^(true|t|yes|y|1)$/i)
+end
 
-    def prep_data
-      puts 'Preparing spec data...'
-      data_fix = fixtures(data_dir)
-      if File.directory?(data_fix)
-        puts "Removing old #{data_fix} directory..."
-        ::FileUtils.remove_entry_secure(data_fix)
-      end
-      puts "Copying Hiera data to #{data_fix}..."
-      ::FileUtils.cp_r(data_dir, data_fix)
-      unless Dir.glob("#{data_fix}/**/*").map { |f| f.delete_prefix('spec/fixtures/') } == Dir.glob("#{data_dir}/**/*")
-        raise 'Spec data copy failed!'
-      end
-      hiera_fix = fixtures(hiera_conf)
-      puts "Copying Hiera config to #{hiera_fix}..."
-      ::FileUtils.cp(hiera_conf, hiera_fix)
-      unless File.exist?(hiera_fix)
-        raise 'Hiera config copy failed!'
-      end
-      puts 'Spec data prepared successfully'
-    end
+def cem_win_spec_format
+  ENV['CEM_WIN_SPEC_FORMAT'] || 'progress'
+end
 
-    def prep_modules
-      puts 'Preparing module fixtures...'
-      mod_fix = fixtures('modules')
-      cache = CemWinSpec::FixtureCache.new
-      cache.copy_fixtures_to(mod_fix)
-    end
-  end
+def cem_win_spec_dir_basenames(dir)
+  Dir.glob("#{dir}/**/*").map { |f| File.basename(f) }
+end
 
-  # Class for defining the cem_win_spec:test task
-  class Test
-    attr_accessor :pattern, :fail_fast, :format
+namespace 'cem_win_spec' do
+  desc 'Run prep and parallel spec tests'
+  task :parallel_spec do
+    Rake::Task['cem_win_spec:prep'].invoke
+    Rake::Task['cem_win_spec:parallel_spec_standalone'].invoke
+  end
 
-    def initialize(namespace = :cem_win_spec)
-      @namespace = namespace
-      @pattern = 'spec/{classes,data_tests,defines,functions,unit}/**/*_spec.rb'
-      @fail_fast = false
-      @format = 'progress'
+  desc 'Prepare spec data and fixtures'
+  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)
+      puts "Removing old #{data_fix} directory..."
+      ::FileUtils.remove_entry_secure(data_fix)
     end
-
-    def define_task
-      namespace @namespace do
-        desc 'Run RSpec tests on Windows host'
-        task :parallel_test do
-          spec_files = Rake::FileList[pattern]
-          pargs = ['--type', 'rspec']
-          rspec_args = ['--']
-          rspec_args << '--fail-fast' if fail_fast
-          rspec_argss.concat(['--format', @format])
-          pargs.concat(rspec_args)
-          pargs << '--'
-          puts "Running tests on Windows host with pattern #{pattern} and args #{pargs}..."
-          pargs.concat(spec_files)
-          ParallelTests::CLI.new.run(pargs)
-        end
-      end
+    puts "Copying Hiera data to #{data_fix}..."
+    ::FileUtils.cp_r(cem_win_spec_data_dir, data_fix)
+    unless cem_win_spec_dir_basenames(data_fix) == cem_win_spec_dir_basenames(cem_win_spec_data_dir)
+      raise 'Spec data copy failed!'
+    end
+    hiera_fix = cem_win_spec_base_path_in_fixtures(cem_win_spec_hiera_conf)
+    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
+    puts 'Spec data prepared successfully'
+    puts 'Preparing module fixtures...'
+    mod_fix = cem_win_spec_base_path_in_fixtures('modules')
+    cache = CemWinSpec::FixtureCache.new
+    cache.copy_fixtures_to(mod_fix)
+    puts 'Module fixtures prepared successfully'
+  end
+
+  desc 'Run RSpec tests on Windows host'
+  task :parallel_spec_standalone do
+    spec_files = Rake::FileList[cem_win_spec_pattern]
+    pargs = ['--type', 'rspec']
+    pargs << '--trace' if cem_win_spec_trace
+    rspec_args = ['--']
+    rspec_args << '--fail-fast' if cem_win_spec_fail_fast
+    rspec_args.concat(['--format', cem_win_spec_format])
+    pargs.concat(rspec_args)
+    pargs << '--'
+    puts "Running tests on Windows host with pattern #{cem_win_spec_pattern} and args #{pargs}..."
+    pargs.concat(spec_files)
+    ParallelTests::CLI.new.run(pargs)
+  end
+
+  desc 'Clean fixture cache'
+  task :clean_fixture_cache do
+    CemWinSpec::FixtureCache.clean!
   end
 end

data/lib/cem_win_spec/test_runner.rb

@@ -83,7 +83,7 @@ module CemWinSpec
 
     def rspec_prep(**opts)
       @rspec_prep ||= new_command('Prepare rspec tests', **opts) do
-        remote_exec('bundle exec rake cem_win_spec:prep')
+        remote_exec('bundle exec rake cem_win_spec:prep --trace')
       end
     end
 
@@ -95,7 +95,7 @@ module CemWinSpec
 
     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_test')
+        remote_exec('bundle exec rake cem_win_spec:parallel_spec')
       end
     end
 
@@ -109,6 +109,12 @@ module CemWinSpec
       end
     end
 
+    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')
+      end
+    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.0"
+  VERSION = "0.1.1"
 end

data/lib/cem_win_spec/win_exec/local_exec.rb

@@ -61,7 +61,7 @@ module CemWinSpec
 
       def exec(cmd, *_args, **_kwargs)
         puts_cmd(cmd)
-        Open3.caputure3(cd_working_dir(cmd))
+        Open3.capture3(cd_working_dir(cmd))
       end
 
       private

data/lib/cem_win_spec/win_exec.rb

@@ -133,7 +133,7 @@ module CemWinSpec
       rescue StandardError => e
         logger.error "Error running #{@title}: #{e.message[0..100]}"
         @result = Output.new(e)
-        raise e unless ignore_exitcode?
+        @result
       end
 
       private

data/lib/cem_win_spec.rb

@@ -22,58 +22,88 @@ module CemWinSpec
     end
   end
 
-  # Runs the tests
+  # Run cem_win_spec operations
   # @param options [Hash] Options for the test runner
   # @option options [Boolean] :quiet (false) Whether to suppress output
   # @option options [Boolean] :debug (false) Whether to enable debug output
-  # @option options [Boolean] :verbose (false) Whether to enable verbose output
   # @option options [String] :log_level (nil) Explicitly set the log level
   # @option options [String] :log_file (nil) Log output to file
   # @option options [String] :log_format (nil) Set log format(text, json, github_action)
-  def self.run_tests(options = {})
+  def self.run(operation = :spec, options = {})
     raise 'Must be ran from the root of the project' unless File.exist?('Gemfile')
 
     log_setup!(options)
-    logger.info 'Running tests'
+    logger.info 'Running cem-win-spec...'
     logger.debug "Options: #{options}"
     runner = TestRunner.new
     logger.debug "Created TestRunner: #{runner}"
     signal_handler(runner)
     logger.debug 'Set up signal handler'
-    exitcode = 99
     spinner = TTY::Spinner.new(format: :classic, interval: 1, hide_cursor: true, clear: true)
     begin
-      runner.enable_long_paths.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}"
-      module_dir = runner.upload_module(working_dir: working_dir).run&.stdout.chomp
+      sre_out = setup_remote_environment(runner, spinner)
+      check_output!(sre_out, runner)
+      module_dir = sre_out.stdout.chomp
       logger.debug "Module dir: #{module_dir}"
-      runner.setup_ruby(operation_timeout: 300,
-                        receive_timeout: 310,
-                        working_dir: module_dir,
-                        reuse_tunnel: false,
-                        spinner: spinner).run
-      runner.rspec_prep(working_dir: module_dir, reuse_tunnel: false, spinner: spinner).run
-      spec_out = runner.rspec_tests_parallel(operation_timeout: 300,
-                                             receive_timeout: 310,
-                                             working_dir: module_dir,
-                                             ignore_exitcode: true,
-                                             reuse_tunnel: false,
-                                             spinner: spinner).run
-      # We currently don't have any local commands being run
-      # but we may in the future. If we do, we'll need to
-      # call local_threaded_results on the TestRunner
-      # runner.local_threaded_results
-      exitcode = spec_out&.exitcode
-      logger.info "Completed tests with exit code: #{exitcode}"
+      srr_out = setup_remote_ruby(runner, module_dir, spinner)
+      check_output!(srr_out, runner)
+      case operation
+      when :spec
+        spec_out = run_spec(runner, module_dir, spinner)
+        check_output!(spec_out, runner)
+      when :clean_fixture_cache
+        clean_fixture_cache_out = clean_fixture_cache(runner, module_dir, spinner)
+        check_output!(clean_fixture_cache_out, runner)
+      else
+        raise ArgumentError, "Unknown operation: #{operation}"
+      end
     rescue StandardError => e
       logger.fatal "Error: #{e.message}"
       logger.debug e.backtrace.join("\n")
-      exitcode = 1
-    ensure
-      exit exitcode
+      exit 1
+    end
+  end
+
+  def self.setup_remote_environment(runner, spinner)
+    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
+  end
+
+  def self.setup_remote_ruby(runner, module_dir, spinner)
+    runner.setup_ruby(operation_timeout: 300,
+                      receive_timeout: 310,
+                      working_dir: module_dir,
+                      reuse_tunnel: false,
+                      spinner: spinner).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
+    runner.rspec_tests_parallel(operation_timeout: 300,
+                                receive_timeout: 310,
+                                working_dir: module_dir,
+                                ignore_exitcode: true,
+                                reuse_tunnel: false,
+                                spinner: spinner).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
+  end
+
+  def self.check_output!(output, runner = nil)
+    unless output.success?
+      runner&.iap_tunnel&.stop(wait: false, log: false)
+      logger.fatal "Command failed with exit code #{output.exitcode}"
+      exit output.exitcode
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cem_win_spec
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Heston Snodgrass
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-10 00:00:00.000000000 Z
+date: 2023-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: winrm