test-kitchen 1.3.1 → 1.4.0.beta.1

data/lib/kitchen/provisioner/chef_solo.rb

@@ -30,7 +30,9 @@ module Kitchen
       default_config :solo_rb, {}
 
       default_config :chef_solo_path do |provisioner|
-        File.join(provisioner[:chef_omnibus_root], %w[bin chef-solo])
+        provisioner.
+          remote_path_join(%W[#{provisioner[:chef_omnibus_root]} bin chef-solo]).
+          tap { |path| path.concat(".bat") if provisioner.windows_os? }
       end
 
       # (see Base#create_sandbox)
@@ -43,17 +45,21 @@ module Kitchen
       def run_command
         level = config[:log_level] == :info ? :auto : config[:log_level]
 
-        cmd = sudo(config[:chef_solo_path])
+        cmd = sudo(config[:chef_solo_path]).dup.
+          tap { |str| str.insert(0, "& ") if powershell_shell? }
         args = [
-          "--config #{config[:root_path]}/solo.rb",
+          "--config #{remote_path_join(config[:root_path], "solo.rb")}",
           "--log_level #{level}",
           "--force-formatter",
           "--no-color",
-          "--json-attributes #{config[:root_path]}/dna.json"
+          "--json-attributes #{remote_path_join(config[:root_path], "dna.json")}"
         ]
         args << "--logfile #{config[:log_file]}" if config[:log_file]
 
-        Util.wrap_command([cmd, *args].join(" "))
+        wrap_shell_code(
+          [cmd, *args].join(" ").
+          tap { |str| str.insert(0, reload_ps1_path) if windows_os? }
+        )
       end
 
       private

data/lib/kitchen/provisioner/chef_zero.rb

@@ -28,13 +28,19 @@ module Kitchen
     class ChefZero < ChefBase
 
       default_config :client_rb, {}
-      default_config :ruby_bindir, "/opt/chef/embedded/bin"
       default_config :json_attributes, true
       default_config :chef_zero_host, nil
       default_config :chef_zero_port, 8889
 
       default_config :chef_client_path do |provisioner|
-        File.join(provisioner[:chef_omnibus_root], %w[bin chef-client])
+        provisioner.
+          remote_path_join(%W[#{provisioner[:chef_omnibus_root]} bin chef-client]).
+          tap { |path| path.concat(".bat") if provisioner.windows_os? }
+      end
+
+      default_config :ruby_bindir do |provisioner|
+        provisioner.
+          remote_path_join(%W[#{provisioner[:chef_omnibus_root]} embedded bin])
       end
 
       # (see Base#create_sandbox)
@@ -49,52 +55,51 @@ module Kitchen
       def prepare_command
         return if modern?
 
-        ruby_bin = Pathname.new(config[:ruby_bindir])
-
-        # we are installing latest chef in order to get chef-zero and
-        # Chef::ChefFS only. The version of Chef that gets run will be
-        # the installed omnibus package. Yep, this is funky :)
-        cmd = <<-PREPARE.gsub(/^ {10}/, "")
-          #{chef_client_zero_env(:export)}
-          if ! #{sudo(ruby_bin.join("gem"))} list chef-zero -i >/dev/null; then
-            echo ">>>>>> Attempting to use chef-zero with old version of Chef"
-            echo "-----> Installing chef zero dependencies"
-            #{sudo(ruby_bin.join("gem"))} install chef --no-ri --no-rdoc --conservative
-          fi
-        PREPARE
-
-        Util.wrap_command(cmd)
+        gem_bin = remote_path_join(config[:ruby_bindir], "gem").
+          tap { |path| path.concat(".bat") if windows_os? }
+        vars = [
+          chef_client_zero_env,
+          shell_var("gem", sudo(gem_bin))
+        ].join("\n").concat("\n")
+
+        shell_code_from_file(vars, "chef_zero_prepare_command_legacy")
       end
 
       # (see Base#run_command)
       def run_command
         cmd = modern? ? local_mode_command : shim_command
 
-        Util.wrap_command([cmd, *chef_client_args].join(" "))
+        wrap_shell_code(
+          [cmd, *chef_client_args].join(" ").
+          tap { |str| str.insert(0, reload_ps1_path) if windows_os? }
+        )
       end
 
       private
 
-      # Returns the command that will run chef client in local mode (a.k.a.
-      # chef zero mode).
+      # Adds optional flags to a chef-client command, depending on
+      # configuration data. Note that this method mutates the incoming Array.
       #
-      # @return [String] the command string
+      # @param args [Array<String>] array of flags
       # @api private
-      def local_mode_command
-        "#{sudo(config[:chef_client_path])} --local-mode"
-      end
+      def add_optional_chef_client_args!(args)
+        if config[:json_attributes]
+          json = remote_path_join(config[:root_path], "dna.json")
+          args << "--json-attributes #{json}"
+        end
+        if config[:log_file]
+          args << "--logfile #{config[:log_file]}"
+        end
+        return unless modern?
 
-      # Returns the command that will run a backwards compatible shim script
-      # that approximates local mode in a modern chef-client run.
-      #
-      # @return [String] the command string
-      # @api private
-      def shim_command
-        [
-          chef_client_zero_env,
-          sudo("#{config[:ruby_bindir]}/ruby"),
-          "#{config[:root_path]}/chef-client-zero.rb"
-        ].join(" ")
+        # these flags are modern/chef-client local most only and will not work
+        # on older versions of chef-client
+        if config[:chef_zero_host]
+          args <<  "--chef-zero-host #{config[:chef_zero_host]}"
+        end
+        if config[:chef_zero_port]
+          args <<  "--chef-zero-port #{config[:chef_zero_port]}"
+        end
       end
 
       # Returns an Array of command line arguments for the chef client.
@@ -104,28 +109,66 @@ module Kitchen
       def chef_client_args
         level = config[:log_level] == :info ? :auto : config[:log_level]
         args = [
-          "--config #{config[:root_path]}/client.rb",
+          "--config #{remote_path_join(config[:root_path], "client.rb")}",
           "--log_level #{level}",
           "--force-formatter",
           "--no-color"
         ]
-
-        if config[:chef_zero_host]
-          args <<  "--chef-zero-host #{config[:chef_zero_host]}"
-        end
-        if config[:chef_zero_port]
-          args <<  "--chef-zero-port #{config[:chef_zero_port]}"
-        end
-        if config[:json_attributes]
-          args << "--json-attributes #{config[:root_path]}/dna.json"
-        end
-        if config[:log_file]
-          args << "--logfile #{config[:log_file]}"
-        end
+        add_optional_chef_client_args!(args)
 
         args
       end
 
+      # Generates a string of shell environment variables needed for the
+      # chef-client-zero.rb shim script to properly function.
+      #
+      # @return [String] a shell script string
+      # @api private
+      def chef_client_zero_env
+        root = config[:root_path]
+        gem_home = gem_path = remote_path_join(root, "chef-client-zero-gems")
+        gem_cache = remote_path_join(gem_home, "cache")
+
+        [
+          shell_env_var("CHEF_REPO_PATH", root),
+          shell_env_var("GEM_HOME", gem_home),
+          shell_env_var("GEM_PATH", gem_path),
+          shell_env_var("GEM_CACHE", gem_cache)
+        ].join("\n").concat("\n")
+      end
+
+      # Returns the command that will run chef client in local mode (a.k.a.
+      # chef zero mode).
+      #
+      # @return [String] the command string
+      # @api private
+      def local_mode_command
+        "#{sudo(config[:chef_client_path])} --local-mode".
+          tap { |str| str.insert(0, "& ") if powershell_shell? }
+      end
+
+      # Determines whether or not local mode (a.k.a chef zero mode) is
+      # supported in the version of Chef as determined by inspecting the
+      # require_chef_omnibus config variable.
+      #
+      # The only way this method returns false is if require_chef_omnibus has
+      # an explicit version set to less than 11.8.0, when chef zero mode was
+      # introduced. Otherwise a modern Chef installation is assumed.
+      #
+      # @return [true,false] whether or not the desired version of Chef
+      #   supports local mode
+      # @api private
+      def modern?
+        version = config[:require_chef_omnibus]
+
+        case version
+        when nil, false, true, "latest"
+          true
+        else
+          Gem::Version.new(version) >= Gem::Version.new("11.8.0") ? true : false
+        end
+      end
+
       # Writes a chef-client local-mode shim script to the sandbox directory
       # only if the desired version of Chef is old enough. The version of Chef
       # is determined using the `config[:require_chef_omnibus]` value.
@@ -142,18 +185,6 @@ module Kitchen
         FileUtils.cp(source, File.join(sandbox_path, "chef-client-zero.rb"))
       end
 
-      # Writes a fake (but valid) validation.pem into the sandbox directory.
-      #
-      # @api private
-      def prepare_validation_pem
-        info("Preparing validation.pem")
-        debug("Using a dummy validation.pem")
-
-        source = File.join(File.dirname(__FILE__),
-          %w[.. .. .. support dummy-validation.pem])
-        FileUtils.cp(source, File.join(sandbox_path, "validation.pem"))
-      end
-
       # Writes a client.rb configuration file to the sandbox directory.
       #
       # @api private
@@ -168,46 +199,29 @@ module Kitchen
         end
       end
 
-      # Generates a string of shell environment variables needed for the
-      # chef-client-zero.rb shim script to properly function.
+      # Writes a fake (but valid) validation.pem into the sandbox directory.
       #
-      # @param extra [Symbol] whether or not the environment variables need to
-      #   be exported, using the `:export` symbol (default: `nil`)
-      # @return [String] a shell script string
       # @api private
-      def chef_client_zero_env(extra = nil)
-        args = [
-          %{CHEF_REPO_PATH="#{config[:root_path]}"},
-          %{GEM_HOME="#{config[:root_path]}/chef-client-zero-gems"},
-          %{GEM_PATH="#{config[:root_path]}/chef-client-zero-gems"},
-          %{GEM_CACHE="#{config[:root_path]}/chef-client-zero-gems/cache"}
-        ]
-        if extra == :export
-          args << %{; export CHEF_REPO_PATH GEM_HOME GEM_PATH GEM_CACHE;}
-        end
-        args.join(" ")
+      def prepare_validation_pem
+        info("Preparing validation.pem")
+        debug("Using a dummy validation.pem")
+
+        source = File.join(File.dirname(__FILE__),
+          %w[.. .. .. support dummy-validation.pem])
+        FileUtils.cp(source, File.join(sandbox_path, "validation.pem"))
       end
 
-      # Determines whether or not local mode (a.k.a chef zero mode) is
-      # supported in the version of Chef as determined by inspecting the
-      # require_chef_omnibus config variable.
-      #
-      # The only way this method returns false is if require_chef_omnibus has
-      # an explicit version set to less than 11.8.0, when chef zero mode was
-      # introduced. Otherwise a modern Chef installation is assumed.
+      # Returns the command that will run a backwards compatible shim script
+      # that approximates local mode in a modern chef-client run.
       #
-      # @return [true,false] whether or not the desired version of Chef
-      #   supports local mode
+      # @return [String] the command string
       # @api private
-      def modern?
-        version = config[:require_chef_omnibus]
+      def shim_command
+        ruby = remote_path_join(config[:ruby_bindir], "ruby").
+          tap { |path| path.concat(".exe") if windows_os? }
+        shim = remote_path_join(config[:root_path], "chef-client-zero.rb")
 
-        case version
-        when nil, false, true, "latest"
-          true
-        else
-          Gem::Version.new(version) >= Gem::Version.new("11.8.0") ? true : false
-        end
+        "#{chef_client_zero_env}\n#{sudo(ruby)} #{shim}"
       end
     end
   end

data/lib/kitchen/provisioner/dummy.rb

@@ -22,7 +22,54 @@ module Kitchen
 
   module Provisioner
 
+    # Dummy provisioner for Kitchen. This driver does nothing but report what
+    # would happen if this provisioner did anything of consequence. As a result
+    # it may be a useful provisioner to use when debugging or developing new
+    # features or plugins.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
     class Dummy < Kitchen::Provisioner::Base
+
+      default_config :sleep, 0
+      default_config :random_failure, false
+
+      # (see Base#call)
+      def call(state)
+        info("[#{name}] Converge on instance=#{instance} with state=#{state}")
+        sleep_if_set
+        failure_if_set
+        debug("[#{name}] Converge completed (#{config[:sleep]}s).")
+      end
+
+      private
+
+      # Sleep for a period of time, if a value is set in the config.
+      #
+      # @api private
+      def sleep_if_set
+        sleep(config[:sleep].to_f) if config[:sleep].to_f > 0.0
+      end
+
+      # Simulate a failure in an action, if set in the config.
+      #
+      # @api private
+      def failure_if_set
+        if config[:"fail"]
+          debug("Failure for Provisioner #{name}.")
+          raise ActionFailed, "Action #converge failed for #{instance.to_str}."
+        elsif config[:random_failure] && randomly_fail?
+          debug("Random failure for Provisioner #{name}.")
+          raise ActionFailed, "Action #converge failed for #{instance.to_str}."
+        end
+      end
+
+      # Determine whether or not to randomly fail.
+      #
+      # @return [true, false]
+      # @api private
+      def randomly_fail?
+        [true, false].sample
+      end
     end
   end
 end

data/lib/kitchen/provisioner/shell.rb

@@ -28,7 +28,8 @@ module Kitchen
     class Shell < Base
 
       default_config :script do |provisioner|
-        provisioner.calculate_path("bootstrap.sh", :type => :file)
+        src = provisioner.powershell_shell? ? "bootstrap.ps1" : "bootstrap.sh"
+        provisioner.calculate_path(src, :type => :file)
       end
       expand_path_for :script
 
@@ -46,17 +47,37 @@ module Kitchen
 
       # (see Base#init_command)
       def init_command
-        data = File.join(config[:root_path], "data")
-        cmd = "#{sudo("rm")} -rf #{data} ; mkdir -p #{config[:root_path]}"
+        root = config[:root_path]
+        data = remote_path_join(root, "data")
+
+        if powershell_shell?
+          Util.outdent!(<<-POWERSHELL)
+            if (Test-Path "#{data}") {
+              Remove-Item "#{data}" -Recurse -Force
+            }
+            if (-Not (Test-Path "#{root}")) {
+              New-Item "#{root}" -ItemType directory | Out-Null
+            }
+          POWERSHELL
+        else
+          cmd = "#{sudo("rm")} -rf #{data} ; mkdir -p #{root}"
 
-        Util.wrap_command(cmd)
+          Util.wrap_command(cmd)
+        end
       end
 
       # (see Base#run_command)
       def run_command
-        Util.wrap_command(
-          sudo(File.join(config[:root_path], File.basename(config[:script])))
+        script = remote_path_join(
+          config[:root_path],
+          File.basename(config[:script])
         )
+
+        if powershell_shell?
+          %{& "#{script}"}
+        else
+          Util.wrap_command(sudo(script))
+        end
       end
 
       private
@@ -87,17 +108,29 @@ module Kitchen
           debug("Using script from #{config[:script]}")
           FileUtils.cp_r(config[:script], sandbox_path)
         else
-          config[:script] = File.join(sandbox_path, "bootstrap.sh")
-          info("#{File.basename(config[:script])} not found " \
-            "so Kitchen will run a stubbed script. Is this intended?")
-          File.open(config[:script], "wb") do |file|
-            file.write(%{#!/bin/sh\necho "NO BOOTSTRAP SCRIPT PRESENT"\n})
-          end
+          prepare_stubbed_script
         end
 
         FileUtils.chmod(0755,
           File.join(sandbox_path, File.basename(config[:script])))
       end
+
+      # Creates a minimal, no-op script in the sandbox path.
+      #
+      # @api private
+      def prepare_stubbed_script
+        base = powershell_shell? ? "bootstrap.ps1" : "bootstrap.sh"
+        config[:script] = File.join(sandbox_path, base)
+        info("#{File.basename(config[:script])} not found " \
+          "so Kitchen will run a stubbed script. Is this intended?")
+        File.open(config[:script], "wb") do |file|
+          if powershell_shell?
+            file.write(%{Write-Host "NO BOOTSTRAP SCRIPT PRESENT`n"\n})
+          else
+            file.write(%{#!/bin/sh\necho "NO BOOTSTRAP SCRIPT PRESENT"\n})
+          end
+        end
+      end
     end
   end
 end

data/lib/kitchen/rake_tasks.rb

@@ -32,7 +32,7 @@ module Kitchen
     # @yield [self] gives itself to the block
     def initialize
       @config = Kitchen::Config.new
-      Kitchen.logger = Kitchen.default_file_logger
+      Kitchen.logger = Kitchen.default_file_logger(nil, false)
       yield self if block_given?
       define
     end