kitchen-pester 0.11.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09484ef2e5522d84210a1a61d4b073e69cf0c16b9c1c04675fcb9ef0d8c734e2'
-  data.tar.gz: 4d503946de43116dd54786eba30913c6f095e1b4bbc9d5bbce72417e0a7cac2d
+  metadata.gz: 5f323e411287a34d2008dc58aba57ced9995e39511e77207031606c01a5b258d
+  data.tar.gz: 45031fdce5ecef091be46aa44e3934afe21e4233d3d1ba469ba2c026105be145
 SHA512:
-  metadata.gz: ed143b476765bb34ee3897284f377e28e9fdd6f60072035d59007db91f7a774e5c0d0c0e975aafb856d8042796abbce77cb954ca3c53a43ba25b05bb7af5cdbd
-  data.tar.gz: 53e54218891590a598aee9718cb5d9137f569784bf3864b8d81a7a9d860a83f8dd033d542c99e51404fe4a75de66a991bce734d4628f8823f52d0b477519c5bc
+  metadata.gz: f1bfc59bc045bd3fe2c3313d6f0fb202f7a8f5887017251610546df15b0b1a644fbd75b4222bc7b9fdad80cd9a97faf4c0abd65eee36c8b54c3aeccc14ed43fd
+  data.tar.gz: 64f70c980a546c5d930f26bbea48e449f4da064feac617bffddd3fbef77649324e7204754af8fdacb41d79594e03bfcbcc779cf90f12b0766f519758070f36f1

data/Gemfile

@@ -11,12 +11,12 @@ group :integration do
 end
 
 group :changelog do
-  gem "github_changelog_generator", "1.15.0"
+  gem "github_changelog_generator", "1.16.4"
 end
 
 group :debug do
-  gem "pry"
-  gem "pry-byebug"
+  gem "pry", "~>0.13.1"
+  gem "pry-byebug", "~>3.9.0"
   gem "pry-stack_explorer"
 end
 

data/Rakefile

@@ -1,5 +1,3 @@
-# -*- encoding: utf-8 -*-
-
 require "bundler/gem_tasks"
 
 require "rake/testtask"
@@ -25,7 +23,7 @@ desc "Run all quality tasks"
 task quality: :style
 
 begin
-  require "yard"
+  require "yard" unless defined?(YARD)
   YARD::Rake::YardocTask.new
 rescue LoadError
   puts "yard is not available. (sudo) gem install yard to generate yard documentation."

data/kitchen-pester.gemspec

@@ -1,5 +1,4 @@
-# encoding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "kitchen/verifier/pester_version"

data/lib/kitchen/verifier/pester.rb

@@ -1,5 +1,3 @@
-# -*- encoding: utf-8 -*-
-#
 # Author:: Steven Murawski (<steven.murawski@gmail.com>)
 #
 # Copyright (C) 2015, Steven Murawski
@@ -16,9 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require "pathname"
+require "fileutils" unless defined?(FileUtils)
+require "pathname" unless defined?(Pathname)
+require "kitchen/util"
 require "kitchen/verifier/base"
 require "kitchen/version"
+require "base64" unless defined?(Base64)
 require_relative "pester_version"
 
 module Kitchen
@@ -32,9 +33,39 @@ module Kitchen
       plugin_version Kitchen::Verifier::PESTER_VERSION
 
       default_config :restart_winrm, false
-      default_config :test_folder
-      default_config :use_local_pester_module, false
-      default_config :downloads, ["./PesterTestResults.xml"] => "./testresults"
+      default_config :test_folder, "tests"
+      default_config :remove_builtin_powershellget, true
+      default_config :remove_builtin_pester, true
+      default_config :skip_pester_install, false
+      default_config :bootstrap, {
+        repository_url: "https://www.powershellgallery.com/api/v2",
+        modules: [],
+      }
+      default_config :register_repository, []
+      default_config :pester_install, {
+        SkipPublisherCheck: true,
+        Force: true,
+        ErrorAction: "Stop",
+      }
+      default_config :pester_configuration, {
+        run: {
+          path: ".",
+          PassThru: true,
+        },
+        TestResult: {
+          Enabled: true,
+          OutputPath: "PesterTestResults.xml",
+          TestSuiteName: "",
+        },
+        Output: {
+          Verbosity: "Detailed",
+        },
+      }
+      default_config :install_modules, []
+      default_config :downloads, { "./PesterTestResults.xml" => "./testresults/" }
+      default_config :copy_folders, []
+      default_config :sudo, false
+      default_config :shell, nil
 
       # Creates a new Verifier object using the provided configuration data
       # which will be merged with any default configuration.
@@ -64,21 +95,56 @@ module Kitchen
       #   end
       def create_sandbox
         super
-        prepare_powershell_modules
+        prepare_supporting_psmodules
+        prepare_copy_folders
         prepare_pester_tests
         prepare_helpers
+
+        debug("\n\n")
+        debug("Sandbox content:\n")
+        list_files(sandbox_path).each do |f|
+          debug("    #{f}")
+        end
       end
 
       # Generates a command string which will install and configure the
       # verifier software on an instance. If no work is required, then `nil`
       # will be returned.
+      # PowerShellGet & Pester Bootstrap are done in prepare_command (after sandbox is transferred)
+      # so that we can use the PesterUtil.psm1
       #
       # @return [String] a command string
       def install_command
-        return if local_suite_files.empty?
-        return if config[:use_local_pester_module]
+        # the sandbox has not yet been copied to the SUT.
+        install_command_string = <<-PS1
+          Write-Verbose 'Running Install Command...'
+          $modulesToRemove = @(
+              if ($#{config[:remove_builtin_powershellget]}) {
+                  Get-module -ListAvailable -FullyQualifiedName @{ModuleName = 'PackageManagement'; RequiredVersion = '1.0.0.1'}
+                  Get-module -ListAvailable -FullyQualifiedName @{ModuleName = 'PowerShellGet'; RequiredVersion = '1.0.0.1'}
+              }
 
-        really_wrap_shell_code(install_command_script)
+              if ($#{config[:remove_builtin_pester]}) {
+                  Get-module -ListAvailable -FullyQualifiedName @{ModuleName = 'Pester'; RequiredVersion = '3.4.0'}
+              }
+          )
+
+          if ($modulesToRemove.ModuleBase.Count -eq 0) {
+            # for PS7 on linux
+            return
+          }
+
+          $modulesToRemove.ModuleBase | Foreach-Object {
+              $ModuleBaseLeaf = Split-Path -Path $_ -Leaf
+              if ($ModuleBaseLeaf -as [System.version]) {
+                Remove-Item -force -Recurse (Split-Path -Parent -Path $_) -ErrorAction SilentlyContinue
+              }
+              else {
+                Remove-Item -force -Recurse $_ -ErrorAction SilentlyContinue
+              }
+          }
+        PS1
+        really_wrap_shell_code(Util.outdent!(install_command_string))
       end
 
       # Generates a command string which will perform any data initialization
@@ -97,7 +163,11 @@ module Kitchen
       # required, then `nil` will be returned.
       #
       # @return [String] a command string
-      def prepare_command; end
+      def prepare_command
+        info("Preparing the SUT and Pester dependencies...")
+        resolve_downloads_paths!
+        really_wrap_shell_code(install_command_script)
+      end
 
       # Generates a command string which will invoke the main verifier
       # command on the prepared instance. If no work is required, then `nil`
@@ -105,9 +175,38 @@ module Kitchen
       #
       # @return [String] a command string
       def run_command
-        return if local_suite_files.empty?
+        really_wrap_shell_code(invoke_pester_scriptblock)
+      end
 
-        really_wrap_shell_code(run_command_script)
+      # Resolves the remote Downloads path from the verifier root path,
+      # unless they're absolute path (starts with / or C:\)
+      # This updates the config[:downloads], nothing (nil) is returned.
+      #
+      # @return [nil] updates config downloads
+      def resolve_downloads_paths!
+        info("Resolving Downloads path from config.")
+        config[:downloads] = config[:downloads]
+          .map do |source, destination|
+            source = source.to_s
+            info("  resolving remote source's absolute path.")
+            unless source.match?('^/|^[a-zA-Z]:[\\/]') # is Absolute?
+              info("  '#{source}' is a relative path, resolving to: #{File.join(config[:root_path], source)}")
+              source = File.join(config[:root_path], source.to_s).to_s
+            end
+
+            if destination.match?('\\$|/$') # is Folder (ends with / or \)
+              destination = File.join(destination, File.basename(source)).to_s
+            end
+            info("  Destination: #{destination}")
+            if !File.directory?(File.dirname(destination))
+              FileUtils.mkdir_p(File.dirname(destination))
+            else
+              info("  Directory #{File.dirname(destination)} seem to exist.")
+            end
+
+            [ source, destination ]
+          end
+        nil # make sure we do not return anything
       end
 
       # Download functionality was added to the base verifier behavior after
@@ -115,128 +214,304 @@ module Kitchen
       if Gem::Version.new(Kitchen::VERSION) <= Gem::Version.new("2.3.4")
         def call(state)
           super
-
-          download_test_files(state)
+        ensure
+          info("Ensure download test files.")
+          download_test_files(state) unless config[:downloads].nil?
+          info("Download complete.")
+        end
+      else
+        def call(state)
+          super
+        rescue
+          # If the verifier reports failure, we need to download the files ourselves.
+          # Test Kitchen's base verifier doesn't have the download in an `ensure` block.
+          info("Rescue to download test files.")
+          download_test_files(state) unless config[:downloads].nil?
+          # Rethrow original exception, we still want to register the failure.
+          raise
         end
       end
 
       # private
-      def run_command_script
-        <<-CMD
-          Import-Module Pester -Force
-          $TestPath = "#{config[:root_path]}"
-          $OutputFilePath = $TestPath | Join-Path -ChildPath 'PesterTestResults.xml'
-
-          $result = Invoke-Pester -OutputFile $OutputFilePath -OutputFormat NUnitXml -Path $TestPath -Passthru
-          $result | Export-CliXml -Path (Join-Path -Path $TestPath -ChildPath 'result.xml')
+      def invoke_pester_scriptblock
+        <<-PS1
+          $PesterModule = Import-Module -Name Pester -Force -ErrorAction Stop -PassThru
+
+          $TestPath = Join-Path "#{config[:root_path]}" -ChildPath "suites"
+          $OutputFilePath = Join-Path "#{config[:root_path]}" -ChildPath 'PesterTestResults.xml'
+
+          if ($PesterModule.Version.Major -le 4)
+          {
+            Write-Host -Object "Invoke Pester with v$($PesterModule.Version) Options"
+            $options = New-PesterOption -TestSuiteName "Pester - #{instance.to_str}"
+            $defaultPesterParameters = @{
+                Script        = $TestPath
+                OutputFile    = $OutputFilePath
+                OutputFormat  = 'NUnitXml'
+                PassThru      = $true
+                PesterOption  = $options
+            }
+
+            $pesterCmd = Get-Command -Name 'Invoke-Pester'
+            $pesterConfig = #{ps_hash(config[:pester_configuration])}
+            $invokePesterParams = @{}
+
+            foreach ($paramName in $pesterCmd.Parameters.Keys)
+            {
+                $paramValue = $pesterConfig.($paramName)
+
+                if ($paramValue) {
+                    Write-Host -Object "Using $paramName from Yaml config."
+                    $invokePesterParams[$paramName] = $paramValue
+                }
+                elseif ($defaultPesterParameters.ContainsKey($paramName))
+                {
+                    Write-Host -Object "Using $paramName from Defaults: $($defaultPesterParameters[$paramName])."
+                    $invokePesterParams[$paramName] = $defaultPesterParameters[$paramName]
+                }
+            }
+
+            $result = Invoke-Pester @invokePesterParams
+          }
+          else
+          {
+            Write-Host -Object "Invoke Pester with v$($PesterModule.Version) Configuration."
+            $pesterConfigHash = #{ps_hash(config[:pester_configuration])}
+
+            if (-not $pesterConfigHash.ContainsKey('run')) {
+                $pesterConfigHash['run'] = @{}
+            }
+
+            if (-not $pesterConfigHash.ContainsKey('TestResult')) {
+                $pesterConfigHash['TestResult'] = @{}
+            }
+
+            if (-not $pesterConfigHash.run.path) {
+                $pesterConfigHash['run']['path'] = $TestPath
+            }
+
+            if (-not $pesterConfigHash.TestResult.TestSuiteName) {
+                $pesterConfigHash['TestResult']['TestSuiteName'] = 'Pester - #{instance.to_str}'
+            }
+
+            if (-not $pesterConfigHash.TestResult.OutputPath) {
+                $pesterConfigHash['TestResult']['OutputPath'] = $OutputFilePath
+            }
+
+            $PesterConfig = New-PesterConfiguration -Hashtable $pesterConfigHash
+            $result = Invoke-Pester -Configuration $PesterConfig
+          }
+
+          $resultXmlPath = (Join-Path -Path $TestPath -ChildPath 'result.xml')
+          if (Test-Path -Path $resultXmlPath) {
+            $result | Export-CliXml -Path
+          }
+
           $LASTEXITCODE = $result.FailedCount
           $host.SetShouldExit($LASTEXITCODE)
+
           exit $LASTEXITCODE
-        CMD
+        PS1
+      end
+
+      def get_powershell_modules_from_nugetapi
+        # don't return anything is the modules subkey or bootstrap is null
+        return if config.dig(:bootstrap, :modules).nil?
+
+        bootstrap = config[:bootstrap]
+        # if the repository url is set, use that as parameter to Install-ModuleFromNuget. Default is the PSGallery url
+        gallery_url_param = bootstrap[:repository_url] ? "-GalleryUrl '#{bootstrap[:repository_url]}'" : ""
+
+        info("Bootstrapping environment without PowerShellGet Provider...")
+        Array(bootstrap[:modules]).map do |powershell_module|
+          if powershell_module.is_a? Hash
+            <<-PS1
+              ${#{powershell_module[:Name]}} = #{ps_hash(powershell_module)}
+
+              Install-ModuleFromNuget -Module ${#{powershell_module[:Name]}} #{gallery_url_param}
+            PS1
+          else
+            <<-PS1
+              Install-ModuleFromNuget -Module @{Name = '#{powershell_module}'} #{gallery_url_param}
+            PS1
+          end
+        end
+      end
+
+      # Returns the string command to set a PS Repository
+      # for each PSRepo configured.
+      #
+      # @return [Array<String>] array of suite files
+      # @api private
+      def register_psrepository_scriptblock
+        return if config[:register_repository].nil?
+
+        info("Registering a new PowerShellGet Repository")
+        Array(config[:register_repository]).map do |psrepo|
+          # Using Set-PSRepo from ../../*/*/*/PesterUtil.psm1
+          debug("Command to set PSRepo #{psrepo[:Name]}.")
+          <<-PS1
+            Write-Host 'Registering psrepo #{psrepo[:Name]}...'
+            ${#{psrepo[:Name]}} = #{ps_hash(psrepo)}
+            Set-PSRepo -Repository ${#{psrepo[:Name]}}
+          PS1
+        end
+      end
+
+      # Returns the string command set the PSGallery as trusted, and
+      # Install Pester from gallery based on the params from Pester_install_params config
+      #
+      # @return <String> command to install Pester Module
+      # @api private
+      def install_pester
+        return if config[:skip_pester_install]
+
+        pester_install_params = config[:pester_install] || {}
+        <<-PS1
+          if ((Get-PSRepository -Name PSGallery).InstallationPolicy -ne 'Trusted') {
+              Write-Host -Object "Trusting the PSGallery to install Pester without -Force"
+              Set-PSRepository -Name PSGallery -InstallationPolicy Trusted -ErrorAction SilentlyContinue
+          }
+
+          Write-Host "Installing Pester..."
+          $installPesterParams = #{ps_hash(pester_install_params)}
+          $installPesterParams['Name'] = 'Pester'
+          Install-module @installPesterParams
+          Write-Host 'Pester Installed.'
+        PS1
+      end
+
+      # returns a piece of PS scriptblock for each Module to install
+      # from gallery that has been sepcified in install_modules config.
+      #
+      # @return [Array<String>] array of PS commands.
+      # @api private
+      def install_modules_from_gallery
+        return if config[:install_modules].nil?
+
+        Array(config[:install_modules]).map do |powershell_module|
+          if powershell_module.is_a? Hash
+            # Sanitize variable name so that $powershell-yaml becomes $powershell_yaml
+            module_name = powershell_module[:Name].gsub(/[\W]/, "_")
+            # so we can splat that variable to install module
+            <<-PS1
+              $#{module_name} = #{ps_hash(powershell_module)}
+              Write-Host -NoNewline 'Installing #{module_name}'
+              Install-Module @#{module_name}
+              Write-host '... done.'
+            PS1
+          else
+            <<-PS1
+              Write-host -NoNewline 'Installing #{powershell_module} ...'
+              Install-Module -Name '#{powershell_module}'
+              Write-host '... done.'
+            PS1
+          end
+        end
       end
 
       def really_wrap_shell_code(code)
-        wrap_shell_code(Util.outdent!(use_local_powershell_modules(code)))
+        windows_os? ? really_wrap_windows_shell_code(code) : really_wrap_posix_shell_code(code)
+      end
+
+      # Get the defined shell or fall back to pwsh, unless we're on windows where we use powershell
+      # call via sudo if sudo is true.
+      # This allows to use pwsh-preview instead of pwsh, or a full path to a specific binary.
+      def shell_cmd
+        if !config[:shell].nil?
+          config[:sudo] ? "sudo #{config[:shell]}" : "#{config[:shell]}"
+        elsif windows_os?
+          "powershell"
+        else
+          config[:sudo] ? "sudo pwsh" : "pwsh"
+        end
+      end
+
+      def really_wrap_windows_shell_code(code)
+        my_command = <<-PWSH
+          echo "Running as '$(whoami)'..."
+          New-Item -ItemType Directory -Path '#{config[:root_path]}/modules' -Force -ErrorAction SilentlyContinue
+          Set-Location -Path "#{config[:root_path]}"
+          # Send the pwsh here string to the file kitchen_cmd.ps1
+          @'
+          try {
+              Set-ExecutionPolicy Unrestricted -force
+          }
+          catch {
+              $_ | Out-String | Write-Warning
+          }
+          #{Util.outdent!(use_local_powershell_modules(code))}
+          '@ | Set-Content -Path kitchen_cmd.ps1 -Encoding utf8 -Force -ErrorAction 'Stop'
+          # create the modules folder, making sure it's done as current user (not root)
+          #
+          # Invoke the created kitchen_cmd.ps1 file using pwsh
+          #{shell_cmd} ./kitchen_cmd.ps1
+        PWSH
+        wrap_shell_code(Util.outdent!(my_command))
+      end
+
+      # Writing the command to a ps1 file, adding the pwsh shebang
+      # invoke the file
+      def really_wrap_posix_shell_code(code)
+        my_command = <<-BASH
+          echo "Running as '$(whoami)'"
+          # create the modules folder, making sure it's done as current user (not root)
+          mkdir -p #{config[:root_path]}/modules
+          cd #{config[:root_path]}
+          # Send the bash heredoc 'EOF' to the file kitchen_cmd.ps1 using the tool cat
+          cat << 'EOF' > kitchen_cmd.ps1
+          #!/usr/bin/env pwsh
+          #{Util.outdent!(use_local_powershell_modules(code))}
+          EOF
+          chmod +x kitchen_cmd.ps1
+          # Invoke the created kitchen_cmd.ps1 file using pwsh
+          #{shell_cmd} ./kitchen_cmd.ps1
+        BASH
+
+        debug(Util.outdent!(my_command))
+        Util.outdent!(my_command)
       end
 
       def use_local_powershell_modules(script)
-        <<-EOH
-          set-executionpolicy unrestricted -force;
+        <<-PS1
+          Write-Host -Object ("{0} - PowerShell {1}" -f $PSVersionTable.OS,$PSVersionTable.PSVersion)
           $global:ProgressPreference = 'SilentlyContinue'
-          $env:psmodulepath += ";$(join-path (resolve-path $env:temp).path 'verifier/modules')"
+          $PSModPathToPrepend = Join-Path "#{config[:root_path]}" -ChildPath 'modules'
+          Write-Verbose "Adding '$PSModPathToPrepend' to `$Env:PSModulePath."
+          if (!$isLinux -and -not (Test-Path -Path $PSModPathToPrepend)) {
+            # if you create this folder now in Linux, it may run as root (via sudo).
+            $null = New-Item -Path $PSModPathToPrepend -Force -ItemType Directory
+          }
+
+          if ($Env:PSModulePath.Split([io.path]::PathSeparator) -notcontains $PSModPathToPrepend) {
+            $env:PSModulePath   = @($PSModPathToPrepend, $env:PSModulePath) -Join [io.path]::PathSeparator
+          }
+
           #{script}
-        EOH
+        PS1
       end
 
       def install_command_script
-        <<-EOH
-          [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
-          function directory($path){
-            if (test-path $path) {(resolve-path $path).providerpath}
-            else {(resolve-path (mkdir $path)).providerpath}
-          }
-          $VerifierModulePath = directory $env:temp/verifier/modules
-          $VerifierTestsPath = directory $env:temp/verifier/pester
+        <<-PS1
+          $PSModPathToPrepend = "#{config[:root_path]}"
 
-    $env:psmodulepath += ";$VerifierModulePath"
-          function test-module($module){
-            (get-module $module -list) -ne $null
-          }
-          if (-not (test-module pester)) {
-            if (test-module PowerShellGet){
-              import-module PowerShellGet -force
-              import-module PackageManagement -force
-              get-packageprovider -name NuGet -force | out-null
-              install-module Pester -force
-            }
-            else {
-              if (-not (test-module PsGet)){
-              $wc = New-Object -TypeName Net.WebClient
-
-              if($env:http_Proxy){
-                if($env:no_proxy){
-                  Write-Output "Creating WebProxy with 'http_proxy' and 'no_proxy' environment variables.
-                    $webproxy = New-Object System.Net.WebProxy($env:http_Proxy,$true,$env:no_proxy)
-                    }else{
-                  Write-Output "Creating WebProxy with 'http_proxy' environment variable.
-                  $webproxy = New-Object -TypeName System.Net.WebProxy -ArgumentList ($env:http_Proxy)
-                }
+          Import-Module -ErrorAction Stop PesterUtil
 
-                $wc.proxy = $webproxy
-              }
+          #{get_powershell_modules_from_nugetapi.join("\n") unless config.dig(:bootstrap, :modules).nil?}
 
-              Invoke-Expression -Command $wc.DownloadString('http://bit.ly/GetPsGet')
-              }
-              try {
-                import-module psget -force -erroraction stop
-                Install-Module Pester
-              }
-              catch {
-                Write-Output "Installing from Github"
-                $zipfile = join-path(resolve-path "$env:temp/verifier") "pester.zip"
-                if (-not (test-path $zipfile)){
-                  $source = 'https://github.com/pester/Pester/archive/3.3.14.zip'
-                  $wc = New-Object -TypeName Net.WebClient
-
-                  if($env:http_Proxy){
-                    if($env:no_proxy){
-                      Write-Output "Creating WebProxy with 'http_proxy' and 'no_proxy' environment variables."
-                      $webproxy = New-Object System.Net.WebProxy($env:http_Proxy,$true,$env:no_proxy)
-                    }else{
-                      Write-Output "Creating WebProxy with 'http_proxy' environment variable."
-                      $webproxy = New-Object -TypeName System.Net.WebProxy -ArgumentList ($env:http_Proxy)
-                    }
-
-                  $wc.proxy = $webproxy
-                  }
-
-                  [byte[]]$bytes = $wc.DownloadData($source)
-                  [IO.File]::WriteAllBytes($zipfile, $bytes)
-                  $bytes = $null
-                  [gc]::collect()
-                  write-output "Downloaded Pester.zip"
-                }
-                write-output "Creating Shell.Application COM object"
-                $shellcom = new-object -com shell.application
-                Write-Output "Creating COM object for zip file."
-                $zipcomobject = $shellcom.namespace($zipfile)
-                Write-Output "Creating COM object for module destination."
-                $destination = $shellcom.namespace($VerifierModulePath)
-                Write-Output "Unpacking zip file."
-                $destination.CopyHere($zipcomobject.Items(), 0x610)
-                rename-item (join-path $VerifierModulePath "Pester-3.3.14") -newname 'Pester' -force
-              }
-            }
-          }
-          if (-not (test-module Pester)) {
-            throw "Unable to install Pester.  Please include Pester in your base image or install during your converge."
-          }
-        EOH
+          #{register_psrepository_scriptblock.join("\n") unless config[:register_repository].nil?}
+
+          #{install_pester}
+
+          #{install_modules_from_gallery.join("\n") unless config[:install_modules].nil?}
+        PS1
       end
 
       def restart_winrm_service
+        return unless verifier.windows_os?
+
         cmd = "schtasks /Create /TN restart_winrm /TR " \
-              '"powershell -command restart-service winrm" ' \
+              '"powershell -Command Restart-Service winrm" ' \
               "/SC ONCE /ST 00:00 "
         wrap_shell_code(Util.outdent!(<<-CMD
           #{cmd}
@@ -246,19 +521,16 @@ module Kitchen
       end
 
       def download_test_files(state)
-        info("Downloading test result files from #{instance.to_str}")
+        if config[:downloads].nil?
+          info("Skipped downloading test result file from #{instance.to_str}; 'downloads' hash is empty.")
+          return
+        end
 
+        info("Downloading test result files from #{instance.to_str}")
         instance.transport.connection(state) do |conn|
-          config[:downloads].to_h.each do |remotes, local|
-            debug("Downloading #{Array(remotes).join(", ")} to #{local}")
-
-            remotes.each do |file|
-              safe_name = instance.name.gsub(/[^0-9A-Z-]/i, "_")
-              local_path = File.join(local, safe_name, file)
-              remote_path = File.join(config[:root_path], file)
-
-              conn.download(remote_path, local_path)
-            end
+          config[:downloads].each do |remotes, local|
+            debug("downloading #{Array(remotes).join(", ")} to #{local}")
+            conn.download(remotes, local)
           end
         end
 
@@ -271,29 +543,25 @@ module Kitchen
       #
       # @return [Array<String>] array of suite files
       # @api private
-
       def suite_test_folder
         @suite_test_folder ||= File.join(test_folder, config[:suite_name])
       end
 
-      def suite_level_glob
-        Dir.glob(File.join(suite_test_folder, "*"))
-      end
-
-      def suite_verifier_level_glob
-        Dir.glob(File.join(suite_test_folder, "*/**/*"))
-      end
-
-      def local_suite_files
-        suite = suite_level_glob
-        suite_verifier = suite_verifier_level_glob
-        (suite << suite_verifier).flatten!.reject do |f|
-          File.directory?(f)
-        end
+      # Returns the current file's parent folder's full path.
+      #
+      # @return [string]
+      # @api private
+      def script_root
+        @script_root ||= File.dirname(__FILE__)
       end
 
-      def sandboxify_path(path)
-        File.join(sandbox_path, path.sub(%r{#{suite_test_folder}/}i, ""))
+      # Returns the absolute path of the Supporting PS module to
+      # be copied to the SUT via the Sandbox.
+      #
+      # @return [string]
+      # @api private
+      def support_psmodule_folder
+        @support_psmodule_folder ||= Pathname.new(File.join(script_root, "../../support/modules/PesterUtil")).cleanpath
       end
 
       # Returns an Array of common helper filenames currently residing on the
@@ -321,50 +589,128 @@ module Kitchen
         end
       end
 
-      # Copies all test suite files into the suites directory in the sandbox.
+      # Creates a PowerShell hashtable from a ruby map.
+      # The only types supported for now are hash, array, string and Boolean.
       #
       # @api private
-      def prepare_pester_tests
-        info("Preparing to copy files from #{suite_test_folder} to the SUT.")
+      def ps_hash(obj, depth = 0)
+        if [true, false].include? obj
+          %{$#{obj}} # Return $true or $false when value is a bool
+        elsif obj.is_a?(Hash)
+          obj.map do |k, v|
+            # Format "Key = Value" enabling recursion
+            %{#{pad(depth + 2)}#{ps_hash(k)} = #{ps_hash(v, depth + 2)}}
+          end
+            .join("\n") # append \n to the key/value definitions
+            .insert(0, "@{\n") # prepend @{\n
+            .insert(-1, "\n#{pad(depth)}}\n") # append \n}\n
+
+        elsif obj.is_a?(Array)
+          array_string = obj.map { |v| ps_hash(v, depth + 4) }.join(",")
+          "#{pad(depth)}@(\n#{array_string}\n)"
+        else
+          # When the object is not a string nor a hash or array, it will be quoted as a string.
+          # In most cases, PS is smart enough to convert back to the type it needs.
+          "'" + obj.to_s + "'"
+        end
+      end
 
-        local_suite_files.each do |src|
-          dest = sandboxify_path(src)
-          debug("Copying #{src} to #{dest}")
-          FileUtils.mkdir_p(File.dirname(dest))
-          FileUtils.cp(src, dest, preserve: true)
+      # returns the path of the modules subfolder
+      # in the sandbox, where PS Modules and folders will be copied to.
+      #
+      # @api private
+      def sandbox_module_path
+        File.join(sandbox_path, "modules")
+      end
+
+      # copy files into the 'modules' folder of the sandbox,
+      # so that copied folders can be discovered with the updated $Env:PSModulePath.
+      #
+      # @api private
+      def prepare_copy_folders
+        return if config[:copy_folders].nil?
+
+        info("Preparing to copy specified folders to #{sandbox_module_path}.")
+        kitchen_root_path = config[:kitchen_root]
+        config[:copy_folders].each do |folder|
+          debug("copying #{folder}")
+          folder_to_copy = File.join(kitchen_root_path, folder)
+          copy_if_src_exists(folder_to_copy, sandbox_module_path)
         end
       end
 
-      def prepare_powershell_module(name)
-        FileUtils.mkdir_p(File.join(sandbox_path, "modules/#{name}"))
-        FileUtils.cp(
-          File.join(File.dirname(__FILE__), "../../support/powershell/#{name}/#{name}.psm1"),
-          File.join(sandbox_path, "modules/#{name}/#{name}.psm1"),
-          preserve: true
-        )
+      # returns an array of string
+      # Creates a flat list of files contained in a folder.
+      # This is useful when trying to debug what has been copied to
+      # the sandbox.
+      #
+      # @return [Array<String>] array of files in a folder
+      # @api private
+      def list_files(path)
+        base_directory_content = Dir.glob(File.join(path, "*"))
+        nested_directory_content = Dir.glob(File.join(path, "*/**/*"))
+        [base_directory_content, nested_directory_content].flatten
       end
 
-      def prepare_powershell_modules
-        info("Preparing to copy supporting powershell modules.")
-        %w{PesterUtil}.each do |module_name|
-          prepare_powershell_module module_name
+      # Copies all test suite files into the suites directory in the sandbox.
+      #
+      # @api private
+      def prepare_pester_tests
+        info("Preparing to copy files from  '#{suite_test_folder}' to the SUT.")
+        sandboxed_suites_path = File.join(sandbox_path, "suites")
+        copy_if_src_exists(suite_test_folder, sandboxed_suites_path)
+      end
+
+      def prepare_supporting_psmodules
+        info("Preparing to copy files from '#{support_psmodule_folder}' to the SUT.")
+        sandbox_module_path = File.join(sandbox_path, "modules")
+        copy_if_src_exists(support_psmodule_folder, sandbox_module_path)
+      end
+
+      # Copies a folder recursively preserving its layers,
+      # mostly used to copy to the sandbox.
+      #
+      # @api private
+      def copy_if_src_exists(src_to_validate, destination)
+        unless Dir.exist?(src_to_validate)
+          info("The path #{src_to_validate} was not found. Not copying to #{destination}.")
+          return
+        end
+
+        info("Moving #{src_to_validate} to #{destination}")
+        unless Dir.exist?(destination)
+          FileUtils.mkdir_p(destination)
+          debug("Folder '#{destination}' created.")
         end
+        FileUtils.mkdir_p(File.join(destination, "__bugfix"))
+        FileUtils.cp_r(src_to_validate, destination, preserve: true)
       end
 
+      # returns the absolute path of the folders containing the
+      # test suites, use default if not set.
+      #
+      # @api private
       def test_folder
-        return config[:test_base_path] if config[:test_folder].nil?
-
-        absolute_test_folder
+        config[:test_folder].nil? ? config[:test_base_path] : absolute_test_folder
       end
 
+      # returns the absolute path of the relative folders containing the
+      # test suites, use default i not set.
+      #
+      # @api private
       def absolute_test_folder
         path = (Pathname.new config[:test_folder]).realpath
         integration_path = File.join(path, "integration")
-        return path unless Dir.exist?(integration_path)
-
-        integration_path
+        Dir.exist?(integration_path) ? integration_path : path
       end
 
+      # returns a string of space of the specified depth.
+      # This is used to pad messages or when building PS hashtables.
+      #
+      # @api private
+      def pad(depth = 0)
+        " " * depth
+      end
     end
   end
 end

data/lib/kitchen/verifier/pester_version.rb

@@ -1,5 +1,5 @@
 module Kitchen
   module Verifier
-    PESTER_VERSION = "0.11.0".freeze
+    PESTER_VERSION = "1.1.0".freeze
   end
 end

data/lib/support/modules/PesterUtil/PesterUtil.psm1

@@ -0,0 +1,158 @@
+[Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
+
+function Install-ModuleFromNuget {
+    [CmdletBinding()]
+    param (
+        [hashtable]
+        $Module,
+
+        [string]
+        $GalleryUrl = 'https://www.powershellgallery.com/api/v2'
+    )
+
+    $tempPath       = [System.IO.Path]::GetTempPath()
+    $zipFileName    = "{0}.{1}.{2}" -f $Module.Name, $Module.Version, 'zip'
+    $downloadedZip  = Join-Path -Path $tempPath $zipFileName
+    $ModulePath     = Join-Path -Path $PSHome -ChildPath 'Modules'
+    $ModuleFolder   = Join-Path -Path $ModulePath -ChildPath $Module.Name
+
+    if ((Test-Path $ModuleFolder) -and ($PSVersionTable.PSVersion.Major -lt 5 -or $module.Force)) {
+        # Check if available version is correct
+        $ModuleManifest = Join-Path -Path $ModuleFolder -ChildPath "$($Module.Name).psd1"
+        if ((Test-Path -Path $ModuleManifest) -and -not $Module.Force) {
+            # Import-PowerShellDataFile only exists since 5.1
+            $ManifestInfo = Import-LocalizedData -BaseDirectory (Split-Path -Parent -Path $ModuleManifest) -FileName $Module.Name
+            $ModuleVersionNoPreRelease = $Module.Version -replace '-.*$'
+            # Compare the version in manifest with version required without Pre-release
+            if ($ManifestInfo.ModuleVersion -eq $ModuleVersionNoPreRelease) {
+                Write-Host "Module $($Module.Name) already installed, skipping."
+                return
+            }
+            else {
+                Write-Host "Module $($Module.Name) found with version '$($ManifestInfo.ModuleVersion)', expecting '$ModuleVersionNoPreRelease'."
+            }
+        }
+        else {
+            # if incorrect, remove it before install
+            Remove-Item -Recurse -Force -Path $ModuleFolder
+        }
+    }
+    elseif ($PSVersionTable.PSVersion.Major -gt 5) {
+        # skip if the version already exists or if force is enabled
+        $ModuleVersionNoPreRelease = $Module.Version -replace '-.*$'
+        $ModuleFolder  = Join-Path -Path $ModuleFolder -ChildPath $ModuleVersionNoPreRelease
+        if (-not $Module.Force -and (Test-Path -Path $ModuleFolder)) {
+            Write-Verbose -Message "Module already installed."
+            return
+        }
+    }
+
+    if (-not (Test-Path $ModuleFolder)) {
+        $null = New-Item -Path $ModuleFolder -force -ItemType Directory
+    }
+
+    $urlSuffix = "/package/$($Module.Name)/$($Module.Version)".TrimEnd('/')
+    $nupkgUrl = $GalleryUrl.TrimEnd('/') + '/' + $urlSuffix.Trim('/')
+    $webclient = New-Object 'system.net.webclient'
+
+    if ($env:HTTP_PROXY){
+        if ($env:NO_PROXY){
+            Write-Host "Creating WebProxy with 'HTTP_PROXY' and 'NO_PROXY' environment variables."
+            $webproxy = New-Object -TypeName System.Net.WebProxy -ArgumentList $env:HTTP_PROXY, $true, $env:NO_PROXY
+        }
+        else {
+            Write-Host "Creating WebProxy with 'HTTP_PROXY' environment variable."
+            $webproxy = New-Object -TypeName System.Net.WebProxy -ArgumentList $env:HTTP_PROXY
+        }
+
+        $webclient.Proxy = $webproxy
+    }
+
+    Write-Verbose -Message "Downloading Package from $nupkgUrl"
+    try {
+        if (Test-Path $downloadedZip) {
+            Remove-Item -Force -ErrorAction SilentlyContinue -Path $downloadedZip
+        }
+        $webclient.DownloadFile($nupkgUrl, $downloadedZip)
+    }
+    catch {
+        Write-Error "Error trying to download nupkg '$nupkgUrl' to '$downloadedZip'."
+        throw $_
+    }
+    
+    if (-not (Test-Path -Path $downloadedZip)) {
+        throw "Error trying to download nupkg '$nupkgUrl' to '$downloadedZip'."
+    }
+    
+    # Test to see if Expand-Archive is available first
+    if (Get-Command Expand-Archive) {
+        Expand-Archive -Path $downloadedZip -DestinationPath $ModuleFolder -Force
+    }
+    else {
+        # Fall back to COM object for Shell.Application zip extraction
+        Write-Host "Creating COM object for zip file '$downloadedZip'."
+        $shellcom = New-Object -ComObject Shell.Application
+        $zipcomobject = $shellcom.Namespace($downloadedZip)
+        $destination = $shellcom.Namespace($ModuleFolder)
+        $destination.CopyHere($zipcomobject.Items(), 0x610)
+        Write-Host "Nupkg installed at $ModuleFolder"
+    }
+
+    [GC]::Collect()
+}
+
+function Set-PSRepo {
+    param(
+        [Parameter(Mandatory)]
+        $Repository
+    )
+    
+    if (-not (Get-Command Get-PSRepository) -and (Get-Command Get-PackageSource)) {
+        # Old versions of PSGet do not have a *-PSrepository but have *-PackageSource instead.
+        if (Get-PackageSource -Name $Repository.Name)  {
+            Set-PackageSource @Repository
+        }
+        else {
+            Register-PackageSource @Repository
+        }
+    }
+    elseif (Get-Command Get-PSRepository) {
+        if (Get-PSRepository -Name $Repository.Name -ErrorAction SilentlyContinue) {
+            # The repo exists, we should use Set-PSRepository and splat parameters
+            Set-PSRepository @Repository
+        }
+        else {
+            # The repo does not exist, use Register-PSRepository and splat
+            Register-PSRepository @Repository
+        }
+    }
+    else {
+        throw "Cannot Set PS Repository, command Set or Register for PSRepository or PackageSource not found."
+    }
+}
+
+function ConvertFrom-PesterOutputObject {
+    param (
+        [parameter(ValueFromPipeline=$true)]
+        [object]
+        $InputObject
+    )
+    begin {
+        $PesterModule = Import-Module Pester -Passthru
+    }
+    process {
+        $DescribeGroup = $InputObject.testresult | Group-Object Describe
+        foreach ($DescribeBlock in $DescribeGroup) {
+            $PesterModule.Invoke({Write-Screen $args[0]}, "Describing $($DescribeBlock.Name)")
+            $ContextGroup = $DescribeBlock.group | Group-Object Context
+            foreach ($ContextBlock in $ContextGroup) {
+                $PesterModule.Invoke({Write-Screen $args[0]}, "`tContext $($subheader.name)")
+                foreach ($TestResult in $ContextBlock.group) {
+                    $PesterModule.Invoke({Write-PesterResult $args[0]}, $TestResult)
+                }
+            }
+        }
+
+        $PesterModule.Invoke({Write-PesterReport $args[0]}, $InputObject)
+    }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-pester
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Steven Murawski
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-25 00:00:00.000000000 Z
+date: 2021-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,12 +105,12 @@ files:
 - kitchen-pester.gemspec
 - lib/kitchen/verifier/pester.rb
 - lib/kitchen/verifier/pester_version.rb
-- lib/support/powershell/PesterUtil/PesterUtil.psm1
+- lib/support/modules/PesterUtil/PesterUtil.psm1
 homepage: https://github.com/test-kitchen/kitchen-pester
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -125,8 +125,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: Test-Kitchen verifier for Pester.
 test_files: []

data/lib/support/powershell/PesterUtil/PesterUtil.psm1

@@ -1,24 +0,0 @@
-function ConvertFrom-PesterOutputObject {
-  param (
-    [parameter(ValueFromPipeline=$true)]
-    [object]
-    $InputObject
-  )
-  begin {
-    $PesterModule = Import-Module Pester -Passthru
-  }
-  process {
-    $DescribeGroup = $InputObject.testresult | Group-Object Describe
-    foreach ($DescribeBlock in $DescribeGroup) {
-      $PesterModule.Invoke({Write-Screen $args[0]}, "Describing $($DescribeBlock.Name)")
-      $ContextGroup = $DescribeBlock.group | Group-Object Context
-      foreach ($ContextBlock in $ContextGroup) {
-        $PesterModule.Invoke({Write-Screen $args[0]}, "`tContext $($subheader.name)")
-        foreach ($TestResult in $ContextBlock.group) {
-          $PesterModule.Invoke({Write-PesterResult $args[0]}, $TestResult)
-        }
-      }
-    }
-    $PesterModule.Invoke({Write-PesterReport $args[0]}, $InputObject)
-  }
-}