test-kitchen 1.0.0.beta.4 → 1.0.0.rc.1

data/lib/kitchen/provisioner/chef_solo.rb

@@ -27,6 +27,8 @@ module Kitchen
     # @author Fletcher Nichol <fnichol@nichol.ca>
     class ChefSolo < ChefBase
 
+      default_config :solo_rb, {}
+
       def create_sandbox
         create_chef_sandbox { prepare_solo_rb }
       end
@@ -34,52 +36,20 @@ module Kitchen
       def run_command
         [
           sudo('chef-solo'),
-          "--config #{home_path}/solo.rb",
-          "--json-attributes #{home_path}/dna.json",
+          "--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(" ")
       end
 
-      def home_path
-        "/tmp/kitchen-chef-solo".freeze
-      end
-
       private
 
       def prepare_solo_rb
-        solo = []
-        solo << %{node_name "#{instance.name}"}
-        solo << %{file_cache_path "#{home_path}/cache"}
-        solo << %{cookbook_path ["#{home_path}/cookbooks","#{home_path}/site-cookbooks"]}
-        solo << %{role_path "#{home_path}/roles"}
-        if config[:chef]
-          if config[:chef][:http_proxy]
-            solo << %{http_proxy "#{config[:chef][:http_proxy]}"}
-          end
-          if config[:chef][:https_proxy]
-            solo << %{https_proxy "#{config[:chef][:https_proxy]}"}
-          end
-          if config[:chef][:no_proxy]
-            solo << %{no_proxy "#{config[:chef][:no_proxy]}"}
-          end
-        end
-        if instance.suite.data_bags_path
-          solo << %{data_bag_path "#{home_path}/data_bags"}
-        end
-        if instance.suite.environments_path
-          solo << %{environment_path "#{home_path}/environments"}
-        end
-        if instance.suite.environment
-          solo << %{environment "#{instance.suite.environment}"}
-        end
-        if instance.suite.encrypted_data_bag_secret_key_path
-          secret = "#{home_path}/encrypted_data_bag_secret"
-          solo << %{encrypted_data_bag_secret "#{secret}"}
-        end
+        data = default_config_rb.merge(config[:solo_rb])
 
         File.open(File.join(tmpdir, "solo.rb"), "wb") do |file|
-          file.write(solo.join("\n"))
+          file.write(format_config_file(data))
         end
       end
     end

data/lib/kitchen/provisioner/chef_zero.rb

@@ -27,97 +27,108 @@ module Kitchen
     # @author Fletcher Nichol <fnichol@nichol.ca>
     class ChefZero < ChefBase
 
-      def initialize(instance, config)
-        super
-        @ruby_binpath = config.fetch(:ruby_binpath, DEFAULT_RUBY_BINPATH)
-      end
+      default_config :client_rb, {}
+      default_config :ruby_bindir, "/opt/chef/embedded/bin"
 
       def create_sandbox
         create_chef_sandbox do
           prepare_chef_client_zero_rb
+          prepare_validation_pem
           prepare_client_rb
         end
       end
 
       def prepare_command
+        return if local_mode_supported?
+
+        ruby_bin = 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 '
-          #{sandbox_env(true)}
-          if ! #{sudo(gem_bin)} list chef-zero -i >/dev/null; then
-            echo "-----> Installing chef-zero and knife-essentials gems"
-            #{sudo(gem_bin)} install \
-              chef-zero knife-essentials --no-ri --no-rdoc
+          #{chef_client_zero_env(:export)}
+          if ! #{sudo("#{ruby_bin}/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'
         PREPARE
       end
 
       def run_command
-        [
-          sandbox_env,
-          sudo(ruby_bin),
-          "#{home_path}/chef-client-zero.rb",
-          "--config #{home_path}/client.rb",
-          "--json-attributes #{home_path}/dna.json",
+        args = [
+          "--config #{config[:root_path]}/client.rb",
+          "--json-attributes #{config[:root_path]}/dna.json",
           "--log_level #{config[:log_level]}"
-        ].join(" ")
-      end
-
-      def home_path
-        "/tmp/kitchen-chef-zero".freeze
-      end
-
-      def gem_bin
-        @gem_bin ||= File.join(ruby_binpath, 'gem')
-      end
-
-      def ruby_bin
-        @ruby_bin ||= File.join(ruby_binpath, 'ruby')
-      end
-
-      private
-
-      DEFAULT_RUBY_BINPATH = "/opt/chef/embedded/bin".freeze
-
-      attr_reader :ruby_binpath
-
-      def sandbox_env(export=false)
-        env = [
-          "GEM_HOME=#{home_path}/gems",
-          "GEM_PATH=$GEM_HOME",
-          "GEM_CACHE=$GEM_HOME/cache",
-          "PATH=$PATH:$GEM_HOME/bin"
         ]
 
-        if export
-          env << "; export GEM_HOME GEM_PATH GEM_CACHE PATH;"
+        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(" ")
         end
-
-        env.join(" ")
       end
 
+      private
+
       def prepare_chef_client_zero_rb
+        return if local_mode_supported?
+
         source = File.join(File.dirname(__FILE__),
           %w{.. .. .. support chef-client-zero.rb})
         FileUtils.cp(source, File.join(tmpdir, "chef-client-zero.rb"))
       end
 
+      def prepare_validation_pem
+        source = File.join(File.dirname(__FILE__),
+          %w{.. .. .. support dummy-validation.pem})
+        FileUtils.cp(source, File.join(tmpdir, "validation.pem"))
+      end
+
       def prepare_client_rb
-        client = []
-        client << %{node_name "#{instance.name}"}
-        client << %{file_cache_path "#{home_path}/cache"}
-        client << %{cookbook_path "#{home_path}/cookbooks"}
-        client << %{node_path "#{home_path}/nodes"}
-        client << %{client_path "#{home_path}/clients"}
-        client << %{role_path "#{home_path}/roles"}
-        client << %{data_bag_path "#{home_path}/data_bags"}
-        if instance.suite.encrypted_data_bag_secret_key_path
-          secret = "#{home_path}/encrypted_data_bag_secret"
-          client << %{encrypted_data_bag_secret "#{secret}"}
-        end
+        data = default_config_rb.merge(config[:client_rb])
 
         File.open(File.join(tmpdir, "client.rb"), "wb") do |file|
-          file.write(client.join("\n"))
+          file.write(format_config_file(data))
+        end
+      end
+
+      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(" ")
+      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.
+      def local_mode_supported?
+        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
     end

data/lib/kitchen/provisioner/dummy.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2013, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'kitchen'
+
+module Kitchen
+
+  module Provisioner
+
+    class Dummy < Kitchen::Provisioner::Base
+    end
+  end
+end

data/lib/kitchen/provisioner.rb

@@ -27,19 +27,21 @@ module Kitchen
   # @author Fletcher Nichol <fnichol@nichol.ca>
   module Provisioner
 
+    # Default provisioner to use
+    DEFAULT_PLUGIN = "chef_solo".freeze
+
     # Returns an instance of a provisioner given a plugin type string.
     #
     # @param plugin [String] a provisioner plugin type, to be constantized
+    # @param config [Hash] a configuration hash to initialize the provisioner
     # @return [Provisioner::Base] a driver instance
     # @raise [ClientError] if a provisioner instance could not be created
-    def self.for_plugin(plugin, instance, config)
+    def self.for_plugin(plugin, config)
       require("kitchen/provisioner/#{plugin}")
 
       str_const = Thor::Util.camel_case(plugin)
       klass = self.const_get(str_const)
-      klass.new(instance, config)
-    rescue UserError
-      raise
+      klass.new(config)
     rescue LoadError, NameError
       raise ClientError,
         "Could not load the '#{plugin}' provisioner from the load path." +

data/lib/kitchen/shell_out.rb

@@ -37,8 +37,6 @@ module Kitchen
     #   sudo
     # @option options [String] :log_subject used in the output or log header
     #   for clarity and context. Default is "local".
-    # @option options [TrueClass, FalseClass] :quiet whether or not to echo
-    #   logging commands. Default is false.
     # @option options [String] :cwd the directory to chdir to before running
     #   the command
     # @option options [Hash] :environment a Hash of environment variables to
@@ -59,14 +57,13 @@ module Kitchen
     # @raise [Error] for all other unexpected exceptions
     def run_command(cmd, options = {})
       use_sudo = options[:use_sudo].nil? ? false : options[:use_sudo]
-      quiet = options[:quiet]
       cmd = "sudo -E #{cmd}" if use_sudo
       subject = "[#{options[:log_subject] || "local"} command]"
 
-      info("#{subject} BEGIN (#{display_cmd(cmd)})") unless quiet
+      debug("#{subject} BEGIN (#{display_cmd(cmd)})")
       sh = Mixlib::ShellOut.new(cmd, shell_opts(options))
       sh.run_command
-      info("#{subject} END #{Util.duration(sh.execution_time)}") unless quiet
+      debug("#{subject} END #{Util.duration(sh.execution_time)}")
       sh.error!
       sh.stdout
     rescue Mixlib::ShellOut::ShellCommandFailed => ex

data/lib/kitchen/ssh.rb

@@ -62,7 +62,7 @@ module Kitchen
       if progress.nil?
         progress = lambda { |ch, name, sent, total|
           if sent == total
-            logger.info("Uploaded #{name} (#{total} bytes)")
+            logger.debug("Uploaded #{name} (#{total} bytes)")
           end
         }
       end

data/lib/kitchen/suite.rb

@@ -18,8 +18,8 @@
 
 module Kitchen
 
-  # A Chef run_list and attribute hash that will be used in a convergence
-  # integration.
+  # A logical configuration representing a test case or fixture that will be
+  # executed on a platform.
   #
   # @author Fletcher Nichol <fnichol@nichol.ca>
   class Suite
@@ -30,91 +30,22 @@ module Kitchen
     # @return [Array] Array of names of excluded platforms
     attr_reader :excludes
 
-    # @return [Hash] suite specific driver_config hash
-    attr_reader :driver_config
+    # @return [Array] Array of names of only included platforms
+    attr_reader :includes
 
     # Constructs a new suite.
     #
     # @param [Hash] options configuration for a new suite
     # @option options [String] :name logical name of this suit (**Required**)
     # @option options [String] :excludes Array of names of excluded platforms
+    # @option options [String] :includes Array of names of only included
+    #   platforms
     def initialize(options = {})
-      options = options.dup
-      validate_options(options)
-
-      @name = options.delete(:name)
-      @excludes = Array(options[:excludes])
-      @driver_config = options.delete(:driver_config) || {}
-      @data = options
-    end
-
-    # Extra suite methods used for accessing Chef data such as a run list,
-    # node attributes, etc.
-    module Cheflike
-
-      # @return [Array] Array of Chef run_list items
-      def run_list
-        Array(data[:run_list])
-      end
-
-      # @return [Hash] Hash of Chef node attributes
-      def attributes
-        data[:attributes] || Hash.new
-      end
-
-      # @return [String] local path to the suite's data bags, or nil if one
-      #   does not exist
-      def data_bags_path
-        data[:data_bags_path]
-      end
-
-      # @return [String] local path to the suite's encrypted data bag secret
-      #   key path, or nil if one does not exist
-      def encrypted_data_bag_secret_key_path
-        data[:encrypted_data_bag_secret_key_path]
-      end
-
-      # @return [String] local path to the suite's roles, or nil if one does
-      #   not exist
-      def roles_path
-        data[:roles_path]
-      end
-
-      # @return [String] local path to the suite's nodes, or nil if one does
-      #   not exist
-      def nodes_path
-        data[:nodes_path]
-      end
-
-      # @return [String] local path to the suite's environments, or nil if one does
-      #   not exist
-      def environments_path
-        data[:environments_path]
-      end
-
-      # @return [String] the suite's environment, or nil if one does
-      #   not exist
-      def environment
-        data[:environment]
-      end
-
-    end
-
-    # Extra suite methods used for accessing Puppet data such as a manifest.
-    module Puppetlike
-
-      def manifest
-      end
-    end
-
-    private
-
-    attr_reader :data
-
-    def validate_options(opts)
-      [:name].each do |k|
-        raise ClientError, "Suite#new requires option :#{k}" if opts[k].nil?
+      @name = options.fetch(:name) do
+        raise ClientError, "Suite#new requires option :name"
       end
+      @excludes = options.fetch(:excludes, [])
+      @includes = options.fetch(:includes, [])
     end
   end
 end

data/lib/kitchen/util.rb

@@ -154,7 +154,7 @@ module Kitchen
           return 0
         }
 
-        # do_curl URL FILENAME
+        # do_perl URL FILENAME
         do_perl() {
           echo "trying perl..."
           perl -e "use LWP::Simple; getprint($ARGV[0]);" "$1" > "$2"
@@ -168,7 +168,7 @@ module Kitchen
           return 0
         }
 
-        # do_curl URL FILENAME
+        # do_python URL FILENAME
         do_python() {
           echo "trying python..."
           python -c "import sys,urllib2 ; sys.stdout.write(urllib2.urlopen(sys.argv[1]).read())" "$1" > "$2"