test-kitchen 1.2.1 → 1.3.0

data/lib/kitchen/provisioner/chef_solo.rb

@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen/provisioner/chef_base'
+require "kitchen/provisioner/chef_base"
 
 module Kitchen
 
@@ -29,26 +29,44 @@ module Kitchen
 
       default_config :solo_rb, {}
 
+      default_config :chef_solo_path do |provisioner|
+        File.join(provisioner[:chef_omnibus_root], %w[bin chef-solo])
+      end
+
+      # (see Base#create_sandbox)
       def create_sandbox
         super
         prepare_solo_rb
       end
 
+      # (see Base#run_command)
       def run_command
-        [
-          sudo('chef-solo'),
+        level = config[:log_level] == :info ? :auto : config[:log_level]
+
+        cmd = sudo(config[:chef_solo_path])
+        args = [
           "--config #{config[:root_path]}/solo.rb",
-          "--json-attributes #{config[:root_path]}/dna.json",
-          config[:log_file] ? "--logfile #{config[:log_file]}" : nil,
-          "--log_level #{config[:log_level]}"
-        ].join(" ")
+          "--log_level #{level}",
+          "--force-formatter",
+          "--no-color",
+          "--json-attributes #{config[:root_path]}/dna.json"
+        ]
+        args << "--logfile #{config[:log_file]}" if config[:log_file]
+
+        Util.wrap_command([cmd, *args].join(" "))
       end
 
       private
 
+      # Writes a solo.rb configuration file to the sandbox directory.
+      #
+      # @api private
       def prepare_solo_rb
         data = default_config_rb.merge(config[:solo_rb])
 
+        info("Preparing solo.rb")
+        debug("Creating solo.rb from #{data.inspect}")
+
         File.open(File.join(sandbox_path, "solo.rb"), "wb") do |file|
           file.write(format_config_file(data))
         end

data/lib/kitchen/provisioner/chef_zero.rb

@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen/provisioner/chef_base'
+require "kitchen/provisioner/chef_base"
 
 module Kitchen
 
@@ -30,7 +30,14 @@ module Kitchen
       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])
+      end
+
+      # (see Base#create_sandbox)
       def create_sandbox
         super
         prepare_chef_client_zero_rb
@@ -38,71 +45,136 @@ module Kitchen
         prepare_client_rb
       end
 
+      # (see Base#prepare_command)
       def prepare_command
-        return if local_mode_supported?
+        return if modern?
 
-        ruby_bin = config[:ruby_bindir]
+        ruby_bin = Pathname.new(config[:ruby_bindir])
 
-        # use Bourne (/bin/sh) as Bash does not exist on all Unix flavors
-        #
-        # * 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 :)
-        <<-PREPARE.gsub(/^ {10}/, '')
-          sh -c '
+        # 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}/gem")} list chef-zero -i >/dev/null; then
+          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}/gem")} install chef --no-ri --no-rdoc --conservative
-          fi'
+            #{sudo(ruby_bin.join("gem"))} install chef --no-ri --no-rdoc --conservative
+          fi
         PREPARE
+
+        Util.wrap_command(cmd)
       end
 
+      # (see Base#run_command)
       def run_command
+        cmd = modern? ? local_mode_command : shim_command
+
+        Util.wrap_command([cmd, *chef_client_args].join(" "))
+      end
+
+      private
+
+      # 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"
+      end
+
+      # 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(" ")
+      end
+
+      # Returns an Array of command line arguments for the chef client.
+      #
+      # @return [Array<String>] an array of command line arguments
+      # @api private
+      def chef_client_args
+        level = config[:log_level] == :info ? :auto : config[:log_level]
         args = [
           "--config #{config[:root_path]}/client.rb",
-          "--log_level #{config[:log_level]}"
+          "--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 local_mode_supported?
-          ["#{sudo('chef-client')} -z"].concat(args).join(" ")
-        else
-          [
-            chef_client_zero_env,
-            sudo("#{config[:ruby_bindir]}/ruby"),
-            "#{config[:root_path]}/chef-client-zero.rb"
-          ].concat(args).join(" ")
+        if config[:log_file]
+          args << "--logfile #{config[:log_file]}"
         end
-      end
 
-      private
+        args
+      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.
+      #
+      # @api private
       def prepare_chef_client_zero_rb
-        return if local_mode_supported?
+        return if modern?
+
+        info("Preparing chef-client-zero.rb")
+        debug("Using a vendored chef-client-zero.rb")
 
         source = File.join(File.dirname(__FILE__),
-          %w{.. .. .. support chef-client-zero.rb})
+          %w[.. .. .. support chef-client-zero.rb])
         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})
+          %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
       def prepare_client_rb
         data = default_config_rb.merge(config[:client_rb])
 
+        info("Preparing client.rb")
+        debug("Creating client.rb from #{data.inspect}")
+
         File.open(File.join(sandbox_path, "client.rb"), "wb") do |file|
           file.write(format_config_file(data))
         end
       end
 
+      # Generates a string of shell environment variables needed for the
+      # chef-client-zero.rb shim script to properly function.
+      #
+      # @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]}"},
@@ -123,7 +195,11 @@ module Kitchen
       # 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.
-      def local_mode_supported?
+      #
+      # @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

data/lib/kitchen/provisioner/dummy.rb

@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen'
+require "kitchen"
 
 module Kitchen
 

data/lib/kitchen/provisioner/shell.rb

@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'kitchen/provisioner/base'
+require "kitchen/provisioner/base"
 
 module Kitchen
 
@@ -28,7 +28,7 @@ module Kitchen
     class Shell < Base
 
       default_config :script do |provisioner|
-        provisioner.calculate_path("bootstrap.sh", :script)
+        provisioner.calculate_path("bootstrap.sh", :type => :file)
       end
       expand_path_for :script
 
@@ -37,23 +37,34 @@ module Kitchen
       end
       expand_path_for :data_path
 
+      # (see Base#create_sandbox)
       def create_sandbox
         super
         prepare_data
         prepare_script
       end
 
+      # (see Base#init_command)
       def init_command
         data = File.join(config[:root_path], "data")
-        "#{sudo('rm')} -rf #{data} ; mkdir -p #{config[:root_path]}"
+        cmd = "#{sudo("rm")} -rf #{data} ; mkdir -p #{config[:root_path]}"
+
+        Util.wrap_command(cmd)
       end
 
+      # (see Base#run_command)
       def run_command
-        sudo(File.join(config[:root_path], File.basename(config[:script])))
+        Util.wrap_command(
+          sudo(File.join(config[:root_path], File.basename(config[:script])))
+        )
       end
 
-      protected
+      private
 
+      # Creates a data directory in the sandbox directory, if a data directory
+      # can be found and copies in the tree.
+      #
+      # @api private
       def prepare_data
         return unless config[:data_path]
 
@@ -65,6 +76,10 @@ module Kitchen
         FileUtils.cp_r(Dir.glob("#{config[:data_path]}/*"), tmpdata_dir)
       end
 
+      # Copies the executable script to the sandbox directory or creates a
+      # stub script if one cannot be found.
+      #
+      # @api private
       def prepare_script
         info("Preparing script")
 
@@ -73,7 +88,7 @@ module Kitchen
           FileUtils.cp_r(config[:script], sandbox_path)
         else
           config[:script] = File.join(sandbox_path, "bootstrap.sh")
-          info("#{File.basename(config[:script])} not found " +
+          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})

data/lib/kitchen/rake_tasks.rb

@@ -16,9 +16,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'rake/tasklib'
+require "rake/tasklib"
 
-require 'kitchen'
+require "kitchen"
 
 module Kitchen
 
@@ -39,8 +39,13 @@ module Kitchen
 
     private
 
+    # @return [Config] a Kitchen::Config
     attr_reader :config
 
+    # Generates a test Rake task for each instance and one to test all
+    # instances in serial.
+    #
+    # @api private
     def define
       namespace "kitchen" do
         config.instances.each do |instance|
@@ -51,7 +56,7 @@ module Kitchen
         end
 
         desc "Run all test instances"
-        task "all" => config.instances.map { |i| i.name }
+        task "all" => config.instances.map(&:name)
       end
     end
   end

data/lib/kitchen/shell_out.rb

@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mixlib/shellout'
+require "mixlib/shellout"
 
 module Kitchen
 
@@ -27,7 +27,7 @@ module Kitchen
   module ShellOut
 
     # Wrapped exception for any interally raised shell out commands.
-    class ShellCommandFailed < TransientFailure ; end
+    class ShellCommandFailed < TransientFailure; end
 
     # Executes a command in a subshell on the local running system.
     #
@@ -41,11 +41,11 @@ module Kitchen
     #   the command
     # @option options [Hash] :environment a Hash of environment variables to
     #   set before the command is run. By default, the environment will
-    #   *always* be set to 'LC_ALL' => 'C' to prevent issues with multibyte
+    #   *always* be set to `'LC_ALL' => 'C'` to prevent issues with multibyte
     #   characters in Ruby 1.8. To avoid this, use :environment => nil for
     #   *no* extra environment settings, or
-    #   :environment => {'LC_ALL'=>nil, ...} to set other environment settings
-    #   without changing the locale.
+    #   `:environment => {'LC_ALL'=>nil, ...}` to set other environment
+    #   settings without changing the locale.
     # @option options [Integer] :timeout Numeric value for the number of
     #   seconds to wait on the child process before raising an Exception.
     #   This is calculated as the total amount of time that ShellOut waited on
@@ -56,11 +56,10 @@ module Kitchen
     # @raise [ShellCommandFailed] if the command fails
     # @raise [Error] for all other unexpected exceptions
     def run_command(cmd, options = {})
-      use_sudo = options[:use_sudo].nil? ? false : options[:use_sudo]
-      cmd = "sudo -E #{cmd}" if use_sudo
-      subject = "[#{options[:log_subject] || "local"} command]"
+      cmd = "sudo -E #{cmd}" if options.fetch(:use_sudo, false)
+      subject = "[#{options.fetch(:log_subject, "local")} command]"
 
-      debug("#{subject} BEGIN (#{display_cmd(cmd)})")
+      debug("#{subject} BEGIN (#{cmd})")
       sh = Mixlib::ShellOut.new(cmd, shell_opts(options))
       sh.run_command
       debug("#{subject} END #{Util.duration(sh.execution_time)}")
@@ -68,22 +67,20 @@ module Kitchen
       sh.stdout
     rescue Mixlib::ShellOut::ShellCommandFailed => ex
       raise ShellCommandFailed, ex.message
-    rescue Exception => error
+    rescue Exception => error # rubocop:disable Lint/RescueException
       error.extend(Kitchen::Error)
       raise
     end
 
     private
 
-    def display_cmd(cmd)
-      first_line, newline, rest = cmd.partition("\n")
-      last_char = cmd[cmd.size - 1]
-
-      newline == "\n" ? "#{first_line}\\n...#{last_char}" : cmd
-    end
-
+    # Returns a hash of MixLib::ShellOut options for the command.
+    #
+    # @param options [Hash] a Hash of options
+    # @return [Hash] a new Hash of options, filterd and merged with defaults
+    # @api private
     def shell_opts(options)
-      filtered_opts = options.reject do |key, value|
+      filtered_opts = options.reject do |key, _value|
         [:use_sudo, :log_subject, :quiet].include?(key)
       end
       { :live_stream => logger, :timeout => 60000 }.merge(filtered_opts)