cem_win_spec 0.1.0

data/README.md

@@ -0,0 +1,33 @@
+# 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
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add cem_win_spec
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install cem_win_spec
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+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.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cem_win_spec.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/cem_win_spec.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/cem_win_spec/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "cem_win_spec"
+  spec.version = CemWinSpec::VERSION
+  spec.authors = ["Heston Snodgrass"]
+  spec.email = ["hsnodgrass@users.noreply.github.com"]
+
+  spec.summary = "Write a short summary, because RubyGems requires one."
+  spec.description = "Write a longer description or delete this line."
+  spec.homepage = "https://github.com/hsnodgrass/cem_win_spec"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = ["cem-win-spec"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "winrm", "~> 2.3"
+  spec.add_dependency "winrm-fs", "~> 1.3"
+  spec.add_dependency "tty-spinner", "~> 0.9"
+  spec.add_dependency "puppet_forge", "~> 4.1"
+  spec.add_dependency "parallel_tests", "~> 3.4"
+  spec.add_development_dependency "pry"
+end

data/exe/cem-win-spec

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'cem_win_spec'
+
+# This is a wrapper script for the cem_win_spec gem. It is used to run the
+# cem_win_spec gem from the command line. It is installed as part of the gem
+# and is not intended to be run directly from the source code.
+
+# Parse command line options
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = 'Usage: cem-win-spec [options]'
+
+  opts.on('-v', '--version', 'Print version and exit') do
+    puts "cem-win-spec version #{CemWinSpec::VERSION}"
+    exit 0
+  end
+
+  opts.on('-q', '--quiet', 'Suppress output') do
+    options[:quiet] = true
+  end
+
+  opts.on('-d', '--debug', 'Enable debug output on the console') do
+    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
+
+  opts.on('-L', '--log-file [FILE]', 'Log output to file') do |file|
+    options[:log_file] = file
+  end
+
+  opts.on('-f', '--log-format [FORMAT]', 'Set log format(file, text, json, github_action') do |log_format|
+    options[:log_format] = log_format
+  end
+
+  opts.on('-h', '--help', 'Print this help') do
+    puts opts
+    exit 0
+  end
+end
+parser.parse!
+
+CemWinSpec.run_tests(options)

data/lib/cem_win_spec/fixture_cache.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'pathname'
+require 'puppet_forge'
+require 'yaml'
+
+module CemWinSpec
+  # 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.
+  # The cache works by creating a YAML file that maps module names and
+  class FixtureCache
+    CACHE_MANIFEST = 'cache_manifest.yaml'
+
+    attr_reader :cache_dir, :cache_entries
+
+    def initialize(cache_dir = 'C:\\ProgramData\\cem_win_spec')
+      raise 'FixtureCache must be ran on Windows' unless Gem.win_platform?
+
+      @cache_dir = cache_dir
+      @cache_entries = setup_and_load_cache
+      @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])
+
+        puts "Downloading #{name} #{data[:version]}..."
+        download_and_cache(name, data[:release_slug], data[:checksum])
+      end
+    ensure
+      save_cache_entries
+    end
+
+    def dependencies_from_metadata
+      raise "File metadata.json not found in current directory #{Dir.pwd}" unless File.exist?('metadata.json')
+
+      metadata = JSON.parse(File.read('metadata.json'))
+      return {} unless metadata.key?('dependencies')
+      
+      metadata['dependencies'].each_with_object({}) do |dep, hsh|
+        mod_name = dep['name'].tr('/', '-')
+        latest_valid_release = PuppetForge::Module.find(mod_name).releases.find do |r|
+          dep_version_req_satisfied?(dep['version_requirement'], r.version)
+        end
+
+        hsh[mod_name] = {
+          checksum: module_checksum(mod_name, dep['version_requirement'], latest_valid_release.version),
+          version_req: dep['version_requirement'],
+          version: latest_valid_release.version,
+          release_slug: latest_valid_release.slug,
+        }
+      end
+    end
+
+    def dep_version_req_satisfied?(version_req, version)
+      reqs = version_req.match(%r{^([<>=!]+ \S+)\s*([<>=!]+ \S+)})
+      raise "Invalid version requirement #{version_req}" unless reqs.to_a.length > 1
+
+      reqs.to_a[1..-1].all? { |req| version_req_satisfied?(req, version) }
+    end
+
+    def version_req_satisfied?(version_req, version)
+      Gem::Requirement.create(version_req).satisfied_by?(Gem::Version.new(version))
+    end
+
+    def module_checksum(name, version_req, version)
+      Digest::SHA256.hexdigest("#{name}#{version_req}#{version}")
+    end
+
+    def manifest
+      File.join(cache_dir, CACHE_MANIFEST)
+    end
+
+    def setup_and_load_cache
+      unless Dir.exist?(cache_dir)
+        puts "Creating cache directory #{cache_dir}..."
+        FileUtils.mkdir_p(cache_dir)
+      end
+      unless File.exist?(manifest)
+        puts "Creating cache manifest #{manifest}..."
+        File.write(manifest, {}.to_yaml)
+      end
+      YAML.load_file(manifest)
+    end
+
+    def cached?(checksum)
+      cache_entries.key?(checksum)
+    end
+
+    def download_and_cache(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))
+      tarball_path = File.join(cache_dir, checksum, "#{release_slug}.tar.gz")
+      release.download(Pathname(tarball_path))
+      release.verify(Pathname(tarball_path))
+      PuppetForge::Unpacker.unpack(tarball_path,
+                                   File.join(module_cache_dir, name),
+                                   File.join(module_cache_dir, 'temp'))
+      cache_entries[checksum] = File.join(module_cache_dir, name)
+    end
+
+    def save_cache_entries
+      File.write(manifest, cache_entries.to_yaml)
+    end
+  end
+end

data/lib/cem_win_spec/iap_tunnel.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require_relative 'logging'
+
+module CemWinSpec
+  # This class is used to create a tunnel to a GCP instance
+  class IapTunnel
+    include CemWinSpec::Logging
+
+    # We don't go all the way to 65_535 because gcloud shits the bed
+    # on MacOS when you assign port 65_535 to a tunnel for some reason.
+    EPHEMERAL_PORT_RANGE = (49_152..65_534).to_a.freeze
+
+    attr_reader :pid, :port, :project_id, :zone, :instance_name
+
+    def initialize(project_id = nil, zone = nil, instance_name = nil)
+      @project_id = project_id || get_project_id
+      @zone = zone || get_zone
+      @instance_name = instance_name || get_instance_name
+      @port = find_available_port # Get a random port from the ephemeral port range
+      @pid = nil
+    end
+
+    def running?
+      !@pid.nil?
+    end
+
+    def with
+      return unless block_given?
+
+      start
+      yield port
+    ensure
+      stop
+    end
+
+    def start
+      return if running?
+
+      logger.info 'Starting IAP tunnel...'
+      logger.debug "Running command: #{tunnel_cmd}"
+      @pid = spawn(tunnel_cmd)
+      sleep(5)
+    end
+
+    # This method stops the IAP tunnel
+    # @param wait [Boolean] Whether to wait for the tunnel to stop before returning
+    # @param log [Boolean] Whether to log messages. This must be set to false if you are
+    #   calling this method from within a trap block, otherwise the logger will throw an exception.
+    def stop(wait: true, log: true)
+      return unless running?
+
+      logger.info 'Stopping IAP tunnel...' if log
+      logger.debug "Killing PID: #{@pid}" if log
+      Process.kill('TERM', @pid)
+      Process.waitpid(@pid) if wait
+      @pid = nil
+      logger.info 'IAP tunnel stopped' if log
+    end
+
+    private
+
+    def tunnel_cmd
+      raise 'Port must be set' unless port
+      [
+        'gcloud',
+        'compute',
+        'start-iap-tunnel',
+        instance_name,
+        '5986',
+        "--local-host-port=localhost:#{port}",
+        "--zone=#{zone}",
+        "--project=#{project_id}",
+      ].join(' ')
+    end
+
+    # This function gets the GCP project ID
+    def get_project_id
+      # Get the project ID from the environment
+      project_id = ENV['GCP_PROJECT_ID'] || `gcloud config get-value project`.chomp
+
+      # If the project ID is not set, prompt the user for it
+      if project_id.nil? && ENV['CI']
+        raise 'Please set the GCP_PROJECT_ID environment variable or ensure that gcloud is configured'
+      elsif project_id.nil?
+        puts 'Please enter your GCP project ID:'
+        project_id = $stdin.cooked(&:gets).chomp
+      end
+
+      raise 'GCP project ID cannot be empty' if project_id.empty?
+
+      logger.debug 'GCP project ID is set'
+      # Return the project ID
+      project_id
+    end
+
+    # This function gets the GCP zone
+    def get_zone
+      return @zone if @zone
+
+      # Get the zone from the environment
+      zone = ENV['GCP_ZONE'] || `gcloud config get-value compute/zone`.chomp
+
+      # If the zone is not set, prompt the user for it
+      if zone.nil? && ENV['CI']
+        raise 'Please set the GCP_ZONE environment variable or ensure that gcloud is configured'
+      elsif zone.nil?
+        puts 'Please enter your GCP zone:'
+        zone = $stdin.cooked(&:gets).chomp
+      end
+
+      raise 'GCP zone cannot be empty' if zone.empty?
+
+      logger.debug 'GCP zone is set'
+      # Return the zone
+      zone
+    end
+
+    # This function gets the GCP instance name
+    def get_instance_name
+      # Get the instance name from the environment
+      instance_name = ENV['GCP_INSTANCE_NAME']
+
+      # If the instance name is not set, prompt the user for it
+      if instance_name.nil? && ENV['CI']
+        raise 'Please set the GCP_INSTANCE_NAME environment variable'
+      elsif instance_name.nil?
+        puts 'Please enter your GCP instance name:'
+        instance_name = $stdin.cooked(&:gets).chomp
+      end
+
+      raise 'GCP instance name cannot be empty' if instance_name.empty?
+
+      logger.debug 'GCP instance name is set'
+      # Return the instance name
+      instance_name
+    end
+
+    # This function ensures that gcloud is installed, usable, and authenticated
+    def gcloud_setup
+      # Ensure that gcloud is installed
+      unless system('gcloud --version')
+        raise 'Please install Google Cloud SDK'
+      end
+
+      # Ensure that gcloud is authenticated
+      unless system('gcloud auth list --format=json | grep ACTIVE')
+        raise 'Please run `gcloud auth login`'
+      end
+    end
+
+    # This function finds an available local port to use for the IAP tunnel
+    def find_available_port
+      port_range = EPHEMERAL_PORT_RANGE.dup.shuffle
+      port_range.each do |prt|
+        return prt if local_port_open?(prt)
+      end
+      raise 'No available ports found'
+    end
+
+    # This function checks if a local port is open
+    def local_port_open?(prt)
+      require 'socket'
+      socket = Socket.new(Socket::Constants::AF_INET, Socket::Constants::SOCK_STREAM, 0)
+      socket.bind(Socket.pack_sockaddr_in(prt, '0.0.0.0'))
+      true
+    rescue Errno::EADDRINUSE, Errno::CONNREFUSED
+      false
+    ensure
+      socket&.close
+    end
+  end
+end

data/lib/cem_win_spec/logging/formatter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module CemWinSpec
+  module Logging
+    module Formatter
+      class << self
+        def for(log_format)
+          log_format = log_format.to_s.downcase.to_sym if log_format.respond_to?(:to_s)
+          all.find { |f| f.log_format == log_format }.get
+        end
+
+        private
+
+        def all
+          @all ||= [FileFormatter.new, JSONFormatter.new, TextFormatter.new, GithubActionFormatter.new]
+        end
+      end      
+
+      class FileFormatter
+        attr_reader :log_format
+
+        def initialize
+          @log_format = :file
+        end
+  
+        def get
+          proc do |severity, datetime, progname, msg|
+            format(severity, datetime, progname, msg)
+          end
+        end
+
+        private
+
+        def format(severity, datetime, progname, msg)
+          "[#{datetime}] | #{progname} | #{severity} | #{msg}\n"
+        end
+      end
+
+      class JSONFormatter < FileFormatter
+        def initialize
+          super
+          @log_format = :json
+        end
+
+        private
+
+        def format(severity, datetime, progname, msg)
+          require 'json'
+          {
+            timestamp: datetime,
+            progname: progname,
+            severity: severity,
+            message: msg,
+          }.to_json + "\n"
+        end
+      end
+
+      class TextFormatter < FileFormatter
+        def initialize
+          super
+          @log_format = :text
+        end
+
+        private
+
+        def format(severity, _datetime, _progname, msg)
+          severity == 'INFO' ? "#{msg}\n" : "#{severity}: #{msg}\n"
+        end
+      end
+
+      class GithubActionFormatter < FileFormatter
+        SEV_MAP = {
+          'DEBUG' => '::debug',
+          'INFO' => '::notice',
+          'WARN' => '::warning',
+          'ERROR' => '::error',
+          'FATAL' => '::error',
+        }.freeze
+
+        def initialize
+          super
+          @log_format = :github_action
+        end
+
+        private
+
+        def format(severity, _datetime, _progname, msg)
+          if severity == 'DEBUG'
+            "#{SEV_MAP[severity]}::{#{msg}}\n"
+          else
+            "#{SEV_MAP[severity]} #{msg}\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cem_win_spec/logging.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'logger'
+require_relative 'logging/formatter'
+
+module CemWinSpec
+  # Logging for CemWinSpec
+  module Logging
+    LEVEL_MAP = {
+      'debug' => Logger::DEBUG,
+      'info' => Logger::INFO,
+      'warn' => Logger::WARN,
+      'error' => Logger::ERROR,
+      'fatal' => Logger::FATAL,
+      'unknown' => Logger::UNKNOWN,
+    }
+
+    # Delegator class for when you want to log to multiple devices
+    # at the same time, such as STDOUT and a file.
+    # @param loggers [::Logger] one or more instances of Logger
+    class MultiLogger
+      def initialize(*loggers)
+        @loggers = loggers
+      end
+
+      def method_missing(m, *args, &block)
+        if @loggers.all? { |l| l.respond_to?(m) }
+          @loggers.map { |l| l.send(m, *args, &block) }
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(m, include_private = false)
+        @loggers.all? { |l| l.respond_to?(m) } || super
+      end
+    end
+
+    class << self
+      def log_setup!(options = {})
+        console_l_level = if options[:debug]
+                            new_log_level('debug')
+                          else
+                            new_log_level('info')
+                          end
+        console_l_formatter = if ENV['CI'] || ENV['GITHUB_ACTIONS']
+                                new_log_formatter(options[:log_format] || 'github_action')
+                              else
+                                new_log_formatter(options[:log_format] || 'text')
+                              end
+        file_l_level = new_log_level(options[:log_level] || 'debug')
+        file_l_formatter = new_log_formatter(options[:log_format] || 'file')
+        loggers = []
+        if options[:log_file]
+          loggers << ::Logger.new(
+            options[:log_file],
+            level: file_l_level,
+            formatter: file_l_formatter,
+            progname: 'CemWinSpec',
+            datetime_format: '%Y%m%dT%H%M%S%z',
+          )
+        end
+        unless options[:quiet]
+          loggers << ::Logger.new(
+            $stdout,
+            level: console_l_level,
+            formatter: console_l_formatter,
+            progname: 'CemWinSpec',
+            datetime_format: '%Y%m%dT%H%M%S%z',
+          )
+        end
+        @logger = MultiLogger.new(*loggers)
+      end
+
+      # Exposes a logger instance. Will either use the currently set logger or
+      # create a new one.
+      # @return [Logger]
+      def logger
+        raise 'Logger not set up! Call CemWinSpec::Logging.log_setup! first.' unless @logger
+
+        @logger
+      end
+
+      # Shortcut method for logger.level
+      # @return [Logger::Severity]
+      def current_log_level
+        logger.level
+      end
+
+      # Gets a log level from a string and returns the corresponding
+      # Logger::Severity constant.
+      # @param level [String] the log level to get
+      def new_log_level(level)
+        raise ArgumentError, 'Log level not recognized' unless LEVEL_MAP[level.to_s.downcase]
+
+        LEVEL_MAP[level.downcase]
+      end
+
+      # Shows the current log format style if set, or the default if not.
+      # @return [Symbol] the current log format style
+      def current_log_format
+        @current_log_format ||= :text
+      end
+
+      # Sets the current log format style and returns a proc to be passed to
+      # Logger#formatter=
+      # @param f [Symbol] the log format style to set
+      # @return [Proc] the proc to be passed to Logger#formatter=
+      def new_log_formatter(f)
+        Formatter.for(f)
+      end
+    end
+
+    # Provides class method wrappers for logging methods
+    def self.included(base)
+      class << base
+        def log_setup!(options = {})
+          CemWinSpec::Logging.log_setup!(options)
+        end
+
+        def logger
+          CemWinSpec::Logging.logger
+        end
+
+        def current_log_level
+          CemWinSpec::Logging.current_log_level
+        end
+
+        def new_log_level(level)
+          CemWinSpec::Logging.new_log_level(level)
+        end
+
+        def current_log_format
+          CemWinSpec::Logging.current_log_format
+        end
+
+        def new_log_formatter(f)
+          CemWinSpec::Logging.new_log_formatter(f)
+        end
+      end
+    end
+
+    def log_setup!(options = {})
+      CemWinSpec::Logging.log_setup!(options)
+    end
+
+    # Exposes the logger instance
+    def logger
+      CemWinSpec::Logging.logger
+    end
+
+    # Exposes the current log level
+    def current_log_level
+      CemWinSpec::Logging.current_log_level
+    end
+
+    # Exposes setting the log level
+    def new_log_level(level)
+      CemWinSpec::Logging.new_log_level(level)
+    end
+
+    def current_log_format
+      CemWinSpec::Logging.current_log_format
+    end
+
+    def new_log_formatter(f)
+      CemWinSpec::Logging.new_log_formatter(f)
+    end
+  end
+end