cem_win_spec 0.1.0

data/lib/cem_win_spec/module_archive_builder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require_relative 'logging'
+
+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
+    ].freeze
+
+    attr_reader :module_dir, :allowlist, :tempdir, :archive
+
+    def initialize(module_dir = Dir.pwd, allowlist: FILE_ALLOWLIST)
+      @module_dir = module_dir
+      @module_name = File.basename(module_dir)
+      @allowlist = allowlist
+    end
+
+    alias path archive
+
+    def build
+      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)
+        end
+      end
+    ensure
+      FileUtils.rm_rf(tempdir) if tempdir && File.exist?(tempdir)
+    end
+
+    private
+
+    def create_tempdir
+      @tempdir = Dir.mktmpdir
+      logger.debug "Created tempdir #{tempdir}"
+    end
+
+    def copy_module_to_tempdir
+      FileUtils.cp_r(module_dir, tempdir)
+      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}"
+      end
+    end
+
+    def create_archive
+      @archive = "#{@module_name}.tar.gz"
+      `tar -czf #{archive} -C #{tempdir} #{@module_name}`
+      logger.info "Created module archive #{archive}"
+    end
+  end
+end

data/lib/cem_win_spec/rake_tasks.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+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
+
+    private
+
+    def define_tasks
+      define_prep_task
+      define_test_task
+    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 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
+  end
+
+  # Class for defining the cem_win_spec:prep task
+  class Prep
+    attr_accessor :data_dir, :hiera_conf
+
+    def initialize(namespace = :cem_win_spec)
+      @namespace = namespace
+      @data_dir = 'data'
+      @hiera_conf = 'hiera.yaml'
+    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 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 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 prep_modules
+      puts 'Preparing module fixtures...'
+      mod_fix = fixtures('modules')
+      cache = CemWinSpec::FixtureCache.new
+      cache.copy_fixtures_to(mod_fix)
+    end
+  end
+
+  # Class for defining the cem_win_spec:test task
+  class Test
+    attr_accessor :pattern, :fail_fast, :format
+
+    def initialize(namespace = :cem_win_spec)
+      @namespace = namespace
+      @pattern = 'spec/{classes,data_tests,defines,functions,unit}/**/*_spec.rb'
+      @fail_fast = false
+      @format = 'progress'
+    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
+    end
+  end
+end

data/lib/cem_win_spec/remote_command.rb

@@ -0,0 +1,47 @@
+# 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/rspec_test_cmds.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+module CemWinSpec
+  class RspecTestCmds
+    DEFAULT_PATTERN = 'spec/{classes,defines}/**/*_spec.rb'
+
+    def initialize(pattern: DEFAULT_PATTERN)
+      @pattern = pattern
+    end
+
+    def cmd_standalone(*args)
+      "bundle exec rake 'cem:spec_standalone#{rake_args(nil, *args)}'"
+    end
+
+    def cmd_parallel(*args)
+      "bundle exec rake 'cem:parallel_spec_standalone#{rake_args(*args)}'"
+    end
+
+    def cmd_chunked(*files)
+      "bundle exec rake 'cem:parallel_spec_files#{rake_args(files.join(' '))}'"
+    end
+
+    def prep_cmd
+      'bundle exec rake cem:win_spec_prep'
+    end
+
+    def cmds(*args)
+      spec_files.to_a.collect { |file| rspec_cmd(file, *args) }
+    end
+
+    def cleanup_cmd
+      'bundle exec rake cem:win_spec_clean'
+    end
+
+    def spec_files
+      @spec_files ||= Rake::FileList[@pattern]
+    end
+
+    private
+
+    def rake_args(*args)
+      args.empty? ? '' : "[#{args.join(',')}]"
+    end
+
+    def rspec_cmd(file, *args)
+      "bundle exec rake 'cem:spec_standalone#{rake_args(file, *args)}'"
+    end
+  end
+end

data/lib/cem_win_spec/test_runner.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require_relative 'iap_tunnel'
+require_relative 'logging'
+require_relative 'module_archive_builder'
+require_relative 'rspec_test_cmds'
+require_relative 'win_exec'
+
+module CemWinSpec
+  # Class for running tests on a remote Windows host
+  class TestRunner
+    include CemWinSpec::Logging
+
+    attr_reader :iap_tunnel
+
+    def initialize
+      @module_archive_builder = ModuleArchiveBuilder.new
+      @rspec_cmds = RspecTestCmds.new
+      @iap_tunnel = IapTunnel.new
+      @win_exec_factory = CemWinSpec::WinExec::Factory.new(@iap_tunnel, @module_archive_builder, @rspec_cmds)
+    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?
+    end
+
+    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')
+      end
+    end
+
+    def enable_symlinks(**opts)
+      @enable_symlinks ||= new_command('Enable symlinks', **opts) do
+        remote_exec('fsutil behavior set SymlinkEvaluation L2L:1 R2R:1 L2R:1 R2L:1')
+      end
+    end
+
+    def create_working_dir(**opts)
+      @create_working_dir ||= new_command('Create working directory', **opts) do
+        dir_name = if remote_conn_opts.user.nil?
+                     "cem_windows_#{Time.now.to_i}"
+                   else
+                     "cem_windows_#{remote_conn_opts.user}_#{Time.now.to_i}"
+                   end
+        work_dir = File.join(remote_temp_dir, dir_name.gsub(/[^0-9A-Za-z]/, '_')).gsub(%r{\/}, "\\")
+        remote_create_dir(work_dir)
+        work_dir
+      end
+    end
+
+    def upload_module(**opts)
+      @upload_module ||= new_command('Upload module', **opts) do
+        raise 'No working directory or working directory is not full path' unless remote_working_dir.match?(%r{^[a-zA-Z]:.*})
+
+        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}")
+        logger.debug "Module extracted to #{module_dir}"
+        module_dir
+      end
+    end
+
+    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')
+      end
+    end
+
+    def rspec_prep(**opts)
+      @rspec_prep ||= new_command('Prepare rspec tests', **opts) do
+        remote_exec('bundle exec rake cem_win_spec:prep')
+      end
+    end
+
+    def rspec_tests(**opts)
+      @rspec_tests ||= new_command('Run rspec tests', **opts) do
+        remote_exec(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_test')
+      end
+    end
+
+    def clean_up
+      @clean_up ||= new_command('Cleanup') do |working_dir|
+        if remote_available?
+          remote_exec(cleanup_cmd, quiet: true)
+        else
+          logger.warn 'Cleanup not available'
+        end
+      end
+    end
+
+    private
+
+    def title_sym(title)
+      title.downcase.gsub(/\s*/, '_').to_sym
+    end
+
+    def new_command(title, **opts, &block)
+      logger.debug "Creating command #{title}"
+      wexec = @win_exec_factory.build(title, **opts, &block)
+      logger.info "Created command #{wexec.title}"
+      wexec
+    end
+
+    def run_remote(reuse_tunnel: true, &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 cleanup_cmd(working_dir)
+      <<~EOS
+        Get-ChildItem #{working_dir} -Recurse | Remove-Item -Force
+        Remove-Item -Force #{working_dir}
+      EOS
+    end
+  end
+end

data/lib/cem_win_spec/version.rb

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

data/lib/cem_win_spec/win_exec/base_exec.rb

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

data/lib/cem_win_spec/win_exec/connection_opts.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'io/console'
+require_relative '../logging'
+
+module CemWinSpec
+  module WinExec
+    # Class for holding and managing WinExec options
+    class ConnectionOpts
+      include CemWinSpec::Logging
+
+      CONN_DEFAULTS = {
+        transport: :ssl,
+        max_envelope_size: 307_200,
+        operation_timeout: 60,
+        receive_timeout: 70,
+        retry_limit: 3,
+        retry_delay: 10,
+      }.freeze
+      TPORT_DEFAULTS = {
+        negotiate: {},
+        ssl: {
+          no_ssl_peer_verification: true,
+        },
+        kerberos: {},
+        plaintext: {
+          basic_auth_only: true,
+          disable_sspi: true,
+        },
+      }.freeze
+
+      attr_reader :user
+
+      def initialize(new_host: nil, new_port: nil, user: nil, pass: nil, **kwargs)
+        @host = new_host
+        @port = new_port
+        @user = user || get_user
+        @pass = pass || get_pass
+        @kwargs = kwargs
+      end
+
+      def host
+        @host ||= 'localhost'
+      end
+
+      def port
+        @port ||= port_for_transport(opts[:transport])
+      end
+
+      def pass
+        @pass ||= Digest::SHA256.hexdigest(pt_pass) unless pt_pass.nil?
+      end
+
+      def endpoint
+        @endpoint ||= endpoint_for_transport(opts[:transport])
+      end
+
+      def opts
+        @opts ||= new_opts(@kwargs)
+      end
+
+      def ==(other)
+        raise ArgumentError, 'Can only compare ConnectionOpts with ConnectionOpts' unless other.is_a? ConnectionOpts
+
+        host == other.host &&
+          port == other.port &&
+          user == other.user &&
+          pass == other.pass &&
+          opts == other.opts
+      end
+
+      def to_h
+        opts.dup.merge({ user: user, password: pt_pass, endpoint: endpoint })
+      end
+
+      def digest
+        Digest::SHA256.hexdigest([host, port, user, @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))
+      end
+
+      def merge!(**new_opts)
+        @host = new_opts[:new_host] || host
+        @port = new_opts[:new_port] || port
+        @user = new_opts[:user] || user
+        @pass = new_opts[:pass] || pt_pass
+        @opts = new_opts(opts.merge(new_opts.reject { |k, _v| %i[new_host new_port user pass].include? k }.to_h))
+        self
+      end
+
+      protected
+
+      def pt_pass
+        @pass
+      end
+
+      private
+
+      def opts_merge(**new_opts)
+        {
+          new_host: new_opts[:new_host] || host,
+          new_port: new_opts[:new_port] || port,
+          user: new_opts[:user] || user,
+          pass: new_opts[:pass] || pt_pass,
+          **opts.merge(new_opts.reject { |k, _v| %i[new_host new_port user pass].include? k }.to_h),
+        }
+      end
+
+      def get_user
+        username = ENV['WINRM_USERNAME']
+
+        if username.nil? && !ENV['CI']
+          puts 'WinRM Username: '
+          username = $stdin.cooked(&:gets).chomp
+        end
+
+        raise 'No username provided' if username.nil? || username.empty?
+        
+        logger.debug 'WinRM username is set'
+        username
+      end
+
+      def get_pass
+        password = ENV['WINRM_PASSWORD']
+
+        if password.nil? && !ENV['CI']
+          password = $stdin.getpass('WinRM Password: ')
+        end
+
+        raise 'No password provided' if password.nil? || password.empty?
+
+        logger.debug 'WinRM password is set'
+        password
+      end
+
+      def 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
+        TPORT_DEFAULTS.dup[new_opts_h[:transport]].merge(new_opts_h)
+      end
+
+      def endpoint_for_transport(transport)
+        case transport
+        when :ssl
+          "https://#{host}:#{port}/wsman"
+        else
+          "http://#{host}:#{port}/wsman"
+        end
+      end
+
+      def port_for_transport(transport)
+        logger.debug "Getting default port for transport #{transport}, current port is #{@port}"
+        case transport
+        when :ssl
+          5986
+        else
+          5985
+        end
+      end
+    end
+  end
+end