test-kitchen 1.3.1 → 1.4.0.beta.1

data/lib/kitchen/command/list.rb

@@ -62,13 +62,15 @@ module Kitchen
           color_pad(instance.name),
           color_pad(instance.driver.name),
           color_pad(instance.provisioner.name),
+          color_pad(instance.verifier.name),
+          color_pad(instance.transport.name),
           format_last_action(instance.last_action)
         ]
       end
 
       # Format and color the given last action.
       #
-      # @param [String] the last action
+      # @param last_action [String] the last action
       # @return [String] formated last action
       # @api private
       def format_last_action(last_action)
@@ -90,7 +92,8 @@ module Kitchen
         table = [
           [
             colorize("Instance", :green), colorize("Driver", :green),
-            colorize("Provisioner", :green), colorize("Last Action", :green)
+            colorize("Provisioner", :green), colorize("Verifier", :green),
+            colorize("Transport", :green), colorize("Last Action", :green)
           ]
         ]
         table += Array(result).map { |i| display_instance(i) }

data/lib/kitchen/config.rb

@@ -72,6 +72,11 @@ module Kitchen
     # @api private
     attr_accessor :log_level
 
+    # @return [Boolean] whether to overwrite the log file when
+    #   Test Kitchen runs
+    # @api private
+    attr_accessor :log_overwrite
+
     # Creates a new configuration, representing a particular testing
     # configuration for a project.
     #
@@ -94,6 +99,7 @@ module Kitchen
       @loader         = options.fetch(:loader) { Kitchen::Loader::YAML.new }
       @kitchen_root   = options.fetch(:kitchen_root) { Dir.pwd }
       @log_level      = options.fetch(:log_level) { Kitchen::DEFAULT_LOG_LEVEL }
+      @log_overwrite  = options.fetch(:log_overwrite) { Kitchen::DEFAULT_LOG_OVERWRITE }
       @log_root       = options.fetch(:log_root) { default_log_root }
       @test_base_path = options.fetch(:test_base_path) { default_test_base_path }
     end
@@ -188,7 +194,7 @@ module Kitchen
     end
 
     # Generates the immutable Test Kitchen configuration and reasonable
-    # defaults for Drivers and Provisioners.
+    # defaults for Drivers, Provisioners and Transports.
     #
     # @return [Hash] a configuration Hash
     # @api private
@@ -196,25 +202,19 @@ module Kitchen
       @kitchen_config ||= {
         :defaults => {
           :driver       => Driver::DEFAULT_PLUGIN,
-          :provisioner  => Provisioner::DEFAULT_PLUGIN
+          :provisioner  => Provisioner::DEFAULT_PLUGIN,
+          :verifier     => Verifier::DEFAULT_PLUGIN,
+          :transport    => lambda { |_suite, platform|
+            platform =~ /^win/i ? "winrm" : Transport::DEFAULT_PLUGIN
+          }
         },
         :kitchen_root   => kitchen_root,
         :test_base_path => test_base_path,
-        :log_level      => log_level
+        :log_level      => log_level,
+        :log_overwrite  => log_overwrite
       }
     end
 
-    # Builds a newly configured Busser object, for a given a Suite and Platform.
-    #
-    # @param suite [Suite,#name] a Suite
-    # @param platform [Platform,#name] a Platform
-    # @return [Busser] a new Busser object
-    # @api private
-    def new_busser(suite, platform)
-      bdata = data.busser_data_for(suite.name, platform.name)
-      Busser.new(suite.name, bdata)
-    end
-
     # Builds a newly configured Driver object, for a given Suite and Platform.
     #
     # @param suite [Suite,#name] a Suite
@@ -236,12 +236,13 @@ module Kitchen
     # @api private
     def new_instance(suite, platform, index)
       Instance.new(
-        :busser       => new_busser(suite, platform),
         :driver       => new_driver(suite, platform),
-        :logger       => new_logger(suite, platform, index),
+        :logger       => new_instance_logger(suite, platform, index),
         :suite        => suite,
         :platform     => platform,
         :provisioner  => new_provisioner(suite, platform),
+        :transport    => new_transport(suite, platform),
+        :verifier     => new_verifier(suite, platform),
         :state_file   => new_state_file(suite, platform)
       )
     end
@@ -254,13 +255,15 @@ module Kitchen
     # @param index [Integer] an index used for colorizing output
     # @return [Logger] a new Logger object
     # @api private
-    def new_logger(suite, platform, index)
+    def new_instance_logger(suite, platform, index)
       name = instance_name(suite, platform)
+      log_location = File.join(log_root, "#{name}.log").to_s
       Logger.new(
         :stdout   => STDOUT,
         :color    => Color::COLORS[index % Color::COLORS.size].to_sym,
-        :logdev   => File.join(log_root, "#{name}.log"),
+        :logdev   => log_location,
         :level    => Util.to_logger_level(log_level),
+        :log_overwrite => log_overwrite,
         :progname => name
       )
     end
@@ -287,5 +290,29 @@ module Kitchen
     def new_state_file(suite, platform)
       StateFile.new(kitchen_root, instance_name(suite, platform))
     end
+
+    # Builds a newly configured Transport object, for a given Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [Transport] a new Transport object
+    # @api private
+    def new_transport(suite, platform)
+      tdata = data.transport_data_for(suite.name, platform.name)
+      Transport.for_plugin(tdata[:name], tdata)
+    end
+
+    # Builds a newly configured Verifier object, for a given a Suite and
+    # Platform.
+    #
+    # @param suite [Suite,#name] a Suite
+    # @param platform [Platform,#name] a Platform
+    # @return [Verifier] a new Verifier object
+    # @api private
+    def new_verifier(suite, platform)
+      vdata = data.verifier_data_for(suite.name, platform.name)
+      Verifier.for_plugin(vdata[:name], vdata)
+    end
   end
 end

data/lib/kitchen/configurable.rb

@@ -53,6 +53,7 @@ module Kitchen
       @instance = instance
       expand_paths!
       validate_config!
+      load_needed_dependencies!
 
       self
     end
@@ -65,6 +66,12 @@ module Kitchen
       config[attr]
     end
 
+    # @return [TrueClass,FalseClass] true if `:shell_type` is `"bourne"` (or
+    #   unset, for backwards compatability)
+    def bourne_shell?
+      ["bourne", nil].include?(instance.platform.shell_type)
+    end
+
     # Find an appropriate path to a file or directory, based on graceful
     # fallback rules or returns nil if path cannot be determined.
     #
@@ -117,6 +124,48 @@ module Kitchen
       result
     end
 
+    # Returns the name of this plugin, suitable for display in a CLI.
+    #
+    # @return [String] name of this plugin
+    def name
+      self.class.name.split("::").last
+    end
+
+    # @return [TrueClass,FalseClass] true if `:shell_type` is `"powershell"`
+    def powershell_shell?
+      ["powershell"].include?(instance.platform.shell_type)
+    end
+
+    # Builds a file path based on the `:os_type` (`"windows"` or `"unix"`).
+    #
+    # @return [String] joined path for instance's os_type
+    def remote_path_join(*parts)
+      path = File.join(*parts)
+      windows_os? ? path.gsub("/", "\\") : path.gsub("\\", "/")
+    end
+
+    # @return [TrueClass,FalseClass] true if `:os_type` is `"unix"` (or
+    #   unset, for backwards compatibility)
+    def unix_os?
+      ["unix", nil].include?(instance.platform.os_type)
+    end
+
+    # Performs whatever tests that may be required to ensure that this plugin
+    # will be able to function in the current environment. This may involve
+    # checking for the presence of certain directories, software installed,
+    # etc.
+    #
+    # @raise [UserError] if the plugin will not be able to perform or if a
+    #   documented dependency is missing from the system
+    def verify_dependencies
+      # this method may be left unimplemented if that is applicable
+    end
+
+    # @return [TrueClass,FalseClass] true if `:os_type` is `"windows"`
+    def windows_os?
+      ["windows"].include?(instance.platform.os_type)
+    end
+
     private
 
     # @return [LzayHash] a configuration hash
@@ -148,7 +197,71 @@ module Kitchen
       expanded_paths.each do |key, should_expand|
         next if !should_expand || config[key].nil?
 
-        config[key] = File.expand_path(config[key], root_path)
+        config[key] = if config[key].is_a?(Array)
+          config[key].map { |path| File.expand_path(path, root_path) }
+        else
+          File.expand_path(config[key], root_path)
+        end
+      end
+    end
+
+    # Loads any required third party Ruby libraries or runs any shell out
+    # commands to prepare the plugin. This method will be called in the
+    # context of the main thread of execution and so does not necessarily
+    # have to be thread safe.
+    #
+    # **Note:** any subclasses overriding this method would be well advised
+    # to call super when overriding this method, for example:
+    #
+    # @example overriding `#load_needed_dependencies!`
+    #
+    #   class MyProvisioner < Kitchen::Provisioner::Base
+    #     def load_needed_dependencies!
+    #       super
+    #       # any further work
+    #     end
+    #   end
+    #
+    # @raise [ClientError] if any library loading fails or any of the
+    #   dependency requirements cannot be satisfied
+    # @api private
+    def load_needed_dependencies!
+      # this method may be left unimplemented if that is applicable
+    end
+
+    # @return [Logger] the instance's logger or Test Kitchen's common logger
+    #   otherwise
+    # @api private
+    def logger
+      instance ? instance.logger : Kitchen.logger
+    end
+
+    # Builds a shell environment variable assignment string for the
+    # required shell type.
+    #
+    # @param name [String] variable name
+    # @param value [String] variable value
+    # @return [String] shell variable assignment
+    # @api private
+    def shell_env_var(name, value)
+      if powershell_shell?
+        shell_var("env:#{name}", value)
+      else
+        "#{shell_var(name, value)}; export #{name}"
+      end
+    end
+
+    # Builds a shell variable assignment string for the required shell type.
+    #
+    # @param name [String] variable name
+    # @param value [String] variable value
+    # @return [String] shell variable assignment
+    # @api private
+    def shell_var(name, value)
+      if powershell_shell?
+        %{$#{name} = "#{value}"}
+      else
+        %{#{name}="#{value}"}
       end
     end
 
@@ -164,6 +277,29 @@ module Kitchen
       end
     end
 
+    # Wraps a body of shell code with common context appropriate for the type
+    # of shell.
+    #
+    # @param code [String] the shell code to be wrapped
+    # @return [String] wrapped shell code
+    # @api private
+    def wrap_shell_code(code)
+      env = []
+      if config[:http_proxy]
+        env << shell_env_var("http_proxy", config[:http_proxy])
+        env << shell_env_var("HTTP_PROXY", config[:http_proxy])
+      end
+      if config[:https_proxy]
+        env << shell_env_var("https_proxy", config[:https_proxy])
+        env << shell_env_var("HTTPS_PROXY", config[:https_proxy])
+      end
+      if powershell_shell?
+        env.join("\n").concat("\n").concat(code)
+      else
+        Util.wrap_command(env.join("\n").concat("\n").concat(code))
+      end
+    end
+
     # Class methods which will be mixed in on inclusion of Configurable module.
     module ClassMethods
 

data/lib/kitchen/data_munger.rb

@@ -44,24 +44,11 @@ module Kitchen
       convert_legacy_driver_format!
       convert_legacy_chef_paths_format!
       convert_legacy_require_chef_omnibus_format!
+      convert_legacy_busser_format!
+      convert_legacy_driver_http_proxy_format!
       move_chef_data_to_provisioner!
     end
 
-    # Generate a new Hash of configuration data that can be used to construct
-    # a new Busser object.
-    #
-    # @param suite [String] a suite name
-    # @param platform [String] a platform name
-    # @return [Hash] a new configuration Hash that can be used to construct a
-    #   new Busser
-    def busser_data_for(suite, platform)
-      merged_data_for(:busser, suite, platform, :version).tap do |bdata|
-        set_kitchen_config_at!(bdata, :kitchen_root)
-        set_kitchen_config_at!(bdata, :test_base_path)
-        set_kitchen_config_at!(bdata, :log_level)
-      end
-    end
-
     # Generate a new Hash of configuration data that can be used to construct
     # a new Driver object.
     #
@@ -107,6 +94,36 @@ module Kitchen
       data.fetch(:suites, [])
     end
 
+    # Generate a new Hash of configuration data that can be used to construct
+    # a new Transport object.
+    #
+    # @param suite [String] a suite name
+    # @param platform [String] a platform name
+    # @return [Hash] a new configuration Hash that can be used to construct a
+    #   new Transport
+    def transport_data_for(suite, platform)
+      merged_data_for(:transport, suite, platform).tap do |tdata|
+        set_kitchen_config_at!(tdata, :kitchen_root)
+        set_kitchen_config_at!(tdata, :test_base_path)
+        set_kitchen_config_at!(tdata, :log_level)
+      end
+    end
+
+    # Generate a new Hash of configuration data that can be used to construct
+    # a new Verifier object.
+    #
+    # @param suite [String] a suite name
+    # @param platform [String] a platform name
+    # @return [Hash] a new configuration Hash that can be used to construct a
+    #   new Verifier
+    def verifier_data_for(suite, platform)
+      merged_data_for(:verifier, suite, platform).tap do |vdata|
+        set_kitchen_config_at!(vdata, :kitchen_root)
+        set_kitchen_config_at!(vdata, :test_base_path)
+        set_kitchen_config_at!(vdata, :log_level)
+      end
+    end
+
     private
 
     # @return [Hash] the user data hash
@@ -125,6 +142,93 @@ module Kitchen
       end
     end
 
+    # Destructively moves old-style `:busser` configuration hashes into the
+    # correct `:verifier` hash.
+    #
+    # This method converts the following:
+    #
+    #   {
+    #     :busser => { :one => "two" },
+    #
+    #     :platforms => [
+    #       {
+    #         :name => "ubuntu-12.04",
+    #         :busser => "bar"
+    #       }
+    #     ],
+    #
+    #     :suites => [
+    #       {
+    #         :name => "alpha",
+    #         :busser => { :three => "four" }
+    #       }
+    #     ]
+    #   }
+    #
+    # into the following:
+    #
+    #   {
+    #     :verifier => {
+    #       :name => "busser",
+    #       :one => "two"
+    #     }
+    #
+    #     :platforms => [
+    #       {
+    #         :name => "ubuntu-12.04",
+    #         :verifier => {
+    #           :name => "busser",
+    #           :version => "bar
+    #         }
+    #       }
+    #     ],
+    #
+    #     :suites => [
+    #       {
+    #         :name => "alpha",
+    #         :verifier => {
+    #           :name => "busser",
+    #           :three => "four"
+    #         }
+    #       }
+    #     ]
+    #   }
+    #
+    # @deprecated The following configuration hashes should no longer be
+    #   created in a `:platform`, `:suite`, or common location:
+    #   `:busser`. Use a `:verifier` hash block in their place.
+    # @api private
+    def convert_legacy_busser_format!
+      convert_legacy_busser_format_at!(data)
+      data.fetch(:platforms, []).each do |platform|
+        convert_legacy_busser_format_at!(platform)
+      end
+      data.fetch(:suites, []).each do |suite|
+        convert_legacy_busser_format_at!(suite)
+      end
+    end
+
+    # Destructively moves old-style `:busser` configuration hashes into the
+    # correct `:verifier` hashes. This method has no knowledge of suites,
+    # platforms, or the like, just a vanilla hash.
+    #
+    # @param root [Hash] a hash to use as the root of the conversion
+    # @deprecated The following configuration hashses should no longer be
+    #   created in a Test Kitchen hash: `:busser`. Use a `:verifier` hash
+    #   block in their place.
+    # @api private
+    def convert_legacy_busser_format_at!(root)
+      if root.key?(:busser)
+        bdata = root.delete(:busser)
+        bdata = { :version => bdata } if bdata.is_a?(String)
+        bdata[:name] = "busser" if bdata[:name].nil?
+
+        vdata = root.fetch(:verifier, Hash.new)
+        vdata = { :name => vdata } if vdata.is_a?(String)
+        root[:verifier] = bdata.rmerge(vdata)
+      end
+    end
+
     # Destructively moves Chef-related paths out of a suite hash and into the
     # suite's provisioner sub-hash.
     #
@@ -273,6 +377,130 @@ module Kitchen
       end
     end
 
+    # Copies `:http_proxy` and `:https_proxy` values in a driver hash into the
+    # provisioner and verifier hashes. For backwards compatibility with legacy
+    # Drivers (those inheriting directly from `SSHBase`), the original
+    # values are maintained in the driver hash.
+    #
+    # This method converts the following:
+    #
+    #   {
+    #     :driver => {
+    #       :http_proxy => "http://proxy",
+    #       :https_proxy => "https://proxy"
+    #     },
+    #
+    #     :platforms => [
+    #       {
+    #         :name => "ubuntu-12.04",
+    #         :driver => {
+    #           :http_proxy => "foo"
+    #         }
+    #       }
+    #     ],
+    #
+    #     :suites => [
+    #       {
+    #         :name => "alpha",
+    #         :driver => {
+    #           :https_proxy => "bar"
+    #         }
+    #       }
+    #     ]
+    #   }
+    #
+    # into the following:
+    #
+    #   {
+    #     :driver => {
+    #       :http_proxy => "http://proxy",
+    #       :https_proxy => "https://proxy"
+    #     },
+    #
+    #     :provisioner => {
+    #       :http_proxy => "http://proxy",
+    #       :https_proxy => "https://proxy"
+    #     },
+    #
+    #     :verifier => {
+    #       :http_proxy => "http://proxy",
+    #       :https_proxy => "https://proxy"
+    #     },
+    #
+    #     :platforms => [
+    #       {
+    #         :name => "ubuntu-12.04",
+    #         :driver => {
+    #           :http_proxy => "foo"
+    #         },
+    #         :provisioner => {
+    #           :http_proxy => "foo"
+    #         },
+    #         :verifier => {
+    #           :http_proxy => "foo"
+    #         }
+    #       }
+    #     ],
+    #
+    #     :suites => [
+    #       {
+    #         :name => "alpha",
+    #         :driver => {
+    #           :https_proxy => "bar"
+    #         },
+    #         :provisioner => {
+    #           :https_proxy => "bar"
+    #         },
+    #         :verifier => {
+    #           :https_proxy => "bar"
+    #         }
+    #       }
+    #     ]
+    #   }
+    #
+    # @deprecated The `:http_proxy` and `:https_proxy` should no longer be
+    #   used in driver blocks, they should be added to the provisioner and
+    #   verifier blocks so that they can be independantly configured.
+    #   Provisioners and Verifiers are responsible for HTTP proxying and no
+    #   longer are Drivers responsible for this.
+    # @api private
+    def convert_legacy_driver_http_proxy_format!
+      convert_legacy_driver_http_proxy_format_at!(data)
+      data.fetch(:platforms, []).each do |platform|
+        convert_legacy_driver_http_proxy_format_at!(platform)
+      end
+      data.fetch(:suites, []).each do |suite|
+        convert_legacy_driver_http_proxy_format_at!(suite)
+      end
+    end
+
+    # Copies `:http_proxy` and `:https_proxy` values in a driver hash into
+    # the provisioner and verifier hashes. This method has no knowledge of
+    # suites, platforms, or the like, just a vanilla hash.
+    #
+    # @param root [Hash] a hash to use as the root of the conversion
+    # @deprecated The `:http_proxy` and `:https_proxy` should no longer be
+    #   used in driver blocks, they should be added to the provisioner and
+    #   verifier blocks so that they can be independantly configured.
+    #   Provisioners and Verifiers are responsible for HTTP proxying and no
+    #   longer are Drivers responsible for this.
+    # @api private
+    def convert_legacy_driver_http_proxy_format_at!(root)
+      ddata = root.fetch(:driver, Hash.new)
+
+      [:http_proxy, :https_proxy].each do |key|
+        next unless ddata.is_a?(Hash) && ddata.key?(key)
+
+        pdata = root.fetch(:provisioner, Hash.new)
+        pdata = { :name => pdata } if pdata.is_a?(String)
+        root[:provisioner] = { key => ddata.fetch(key) }.rmerge(pdata)
+
+        vdata = root.fetch(:verifier, Hash.new)
+        vdata = { :name => vdata } if vdata.is_a?(String)
+        root[:verifier] = { key => ddata.fetch(key) }.rmerge(vdata)
+      end
+    end
+
     # Destructively moves a `:require_chef_omnibus` key/value pair from a
     # `:driver` hash block to a `:provisioner` hash block.
     #
@@ -386,7 +614,7 @@ module Kitchen
     # @return [Hash] a new merged Hash
     # @api private
     def merged_data_for(key, suite, platform, default_key = :name)
-      ddata = normalized_default_data(key, default_key)
+      ddata = normalized_default_data(key, default_key, suite, platform)
       cdata = normalized_common_data(key, default_key)
       pdata = normalized_platform_data(key, default_key, platform)
       sdata = normalized_suite_data(key, default_key, suite)
@@ -563,11 +791,14 @@ module Kitchen
     # @param key [Symbol] the value to normalize
     # @param default_key [Symbol] the implicit default key if a String value
     #   is given
+    # @param suite [String] name of a suite
+    # @param platform [String] name of a platform
     # @return [Hash] a shallow Hash copy of the original if not modified, or a
     #   new Hash otherwise
     # @api private
-    def normalized_default_data(key, default_key)
+    def normalized_default_data(key, default_key, suite, platform)
       ddata = kitchen_config.fetch(:defaults, Hash.new).fetch(key, Hash.new).dup
+      ddata = { default_key => ddata.call(suite, platform) } if ddata.is_a?(Proc)
       ddata = { default_key => ddata } if ddata.is_a?(String)
       ddata
     end