test-kitchen 1.1.1 → 1.2.0

data/lib/kitchen/command/sink.rb

@@ -0,0 +1,53 @@
+# -*- 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/command'
+
+module Kitchen
+
+  module Command
+
+    # Command to... include the sink.
+    #
+    # @author Seth Vargo <sethvargo@gmail.com>
+    class Sink < Kitchen::Command::Base
+
+      def call
+        puts [
+          "",
+          "                    ___              ",
+          "                   ' _ '.            ",
+          "                 / /` `\\ \\         ",
+          "                 | |   [__]          ",
+          "                 | |    {{           ",
+          "                 | |    }}           ",
+          "              _  | |  _ {{           ",
+          "  ___________<_>_| |_<_>}}________   ",
+          "      .=======^=(___)=^={{====.      ",
+          "     / .----------------}}---. \\    ",
+          "    / /                 {{    \\ \\  ",
+          "   / /                  }}     \\ \\ ",
+          "  (  '========================='  )  ",
+          "   '-----------------------------'   ",
+          "                                     ",  # necessary newline
+          ""
+        ].map(&:rstrip).join("\n")
+      end
+    end
+  end
+end

data/lib/kitchen/command/test.rb

@@ -0,0 +1,50 @@
+# -*- 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/command'
+
+require 'benchmark'
+
+module Kitchen
+
+  module Command
+
+    # Command to test one or more instances.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Test < Kitchen::Command::Base
+
+      include RunAction
+
+      def call
+        if ! %w{passing always never}.include?(options[:destroy])
+          raise ArgumentError, "Destroy mode must be passing, always, or never."
+        end
+
+        banner "Starting Kitchen (v#{Kitchen::VERSION})"
+        elapsed = Benchmark.measure do
+          destroy_mode = options[:destroy].to_sym
+          results = parse_subcommand(args.join('|'))
+
+          run_action(:test, results, destroy_mode)
+        end
+        banner "Kitchen is finished. #{Util.duration(elapsed.real)}"
+      end
+    end
+  end
+end

data/lib/kitchen/driver/ssh_base.rb

@@ -37,7 +37,8 @@ module Kitchen
 
       def converge(state)
         provisioner = instance.provisioner
-        sandbox_dirs = Dir.glob("#{provisioner.create_sandbox}/*")
+        provisioner.create_sandbox
+        sandbox_dirs = Dir.glob("#{provisioner.sandbox_path}/*")
 
         Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
           run_remote(provisioner.install_command, conn)

data/lib/kitchen/loader/yaml.rb

@@ -18,7 +18,13 @@
 
 require 'erb'
 require 'vendor/hash_recursive_merge'
-require 'safe_yaml'
+
+if RUBY_VERSION <= "1.9.3"
+  # ensure that Psych and not Syck is used for Ruby 1.9.2
+  require 'yaml'
+  YAML::ENGINE.yamler = 'psych'
+end
+require 'safe_yaml/load'
 
 module Kitchen
 
@@ -33,18 +39,27 @@ module Kitchen
     # @author Fletcher Nichol <fnichol@nichol.ca>
     class YAML
 
-      attr_reader :config_file
-
       # Creates a new loader that can parse and load YAML files.
       #
-      # @param config_file [String] path to Kitchen config YAML file
       # @param options [Hash] configuration for a new loader
+      # @option options [String] :project_config path to the Kitchen
+      #   config YAML file (default: `./.kitchen.yml`)
+      # @option options [String] :local_config path to the Kitchen local
+      #   config YAML file (default: `./.kitchen.local.yml`)
+      # @option options [String] :local_config path to the Kitchen global
+      #   config YAML file (default: `$HOME/.kitchen/config.yml`)
       # @option options [String] :process_erb whether or not to process YAML
       #   through an ERB processor (default: `true`)
       # @option options [String] :process_local whether or not to process a
       #   local kitchen YAML file, if it exists (default: `true`)
-      def initialize(config_file = nil, options = {})
-        @config_file = File.expand_path(config_file || default_config_file)
+      def initialize(options = {})
+        @config_file =
+          File.expand_path(options[:project_config] || default_config_file)
+        @local_config_file =
+          File.expand_path(options[:local_config] || default_local_config_file)
+        @global_config_file =
+          File.expand_path(options[:global_config] || default_global_config_file)
+
         @process_erb = options.fetch(:process_erb, true)
         @process_local = options.fetch(:process_local, true)
         @process_global = options.fetch(:process_global, true)
@@ -67,26 +82,20 @@ module Kitchen
       # @return [Hash] a diagnostic hash
       def diagnose
         result = Hash.new
-        result[:proces_erb] = @process_erb
+        result[:process_erb] = @process_erb
         result[:process_local] = @process_local
         result[:process_global] = @process_global
-        if File.exists?(global_config_file)
-          result[:global_config] =
-            { :filename => global_config_file, :raw_data => global_yaml }
-        end
-        result[:project_config] =
-          { :filename => config_file, :raw_data => yaml }
-        if File.exists?(local_config_file)
-          result[:local_config] =
-            { :filename => local_config_file, :raw_data => local_yaml }
-        end
-        combined = begin ; combined_hash ; rescue => e ; failure_hash(e) ; end
-        result[:combined_config] = { :raw_data => combined }
+        result[:global_config] = diagnose_component(:global_yaml, global_config_file)
+        result[:project_config] = diagnose_component(:yaml, config_file)
+        result[:local_config] = diagnose_component(:local_yaml, local_config_file)
+        result[:combined_config] = diagnose_component(:combined_hash)
         result
       end
 
       protected
 
+      attr_reader :config_file, :local_config_file, :global_config_file
+
       def default_config_file
         File.join(Dir.pwd, '.kitchen.yml')
       end
@@ -98,9 +107,6 @@ module Kitchen
           normalize(yaml)
         end
         @process_global ? y.rmerge(normalize(global_yaml)) : y
-      rescue NoMethodError
-        raise UserError, "Error merging #{File.basename(config_file)} and" +
-          "#{File.basename(local_config_file)}"
       end
 
       def yaml
@@ -118,29 +124,52 @@ module Kitchen
       def yaml_string(file)
         string = read_file(file)
 
-        @process_erb ? ERB.new(string).result : string
+        @process_erb ? process_erb(string, file) : string
+      end
+
+      def process_erb(string, file)
+        ERB.new(string).result
+      rescue => e
+        raise UserError, "Error parsing ERB content in #{file} " +
+          "(#{e.class}: #{e.message}).\n" +
+          "Please run `kitchen diagnose --no-instances --loader' to help " +
+          "debug your issue."
       end
 
       def read_file(file)
         File.exists?(file.to_s) ? IO.read(file) : ""
       end
 
-      def local_config_file
+      def default_local_config_file
         config_file.sub(/(#{File.extname(config_file)})$/, '.local\1')
       end
 
-      def global_config_file
+      def default_global_config_file
         File.join(File.expand_path(ENV["HOME"]), ".kitchen", "config.yml")
       end
 
-      def failure_hash(e)
-        {
+      def diagnose_component(component, file = nil)
+        return if file && !File.exists?(file)
+
+        hash = begin
+          send(component)
+        rescue => e
+          failure_hash(e, file)
+        end
+
+        { :filename => file, :raw_data => hash }
+      end
+
+      def failure_hash(e, file = nil)
+        result = {
           :error => {
             :exception => e.inspect,
             :message => e.message,
             :backtrace => e.backtrace
           }
         }
+        result[:error][:raw_file] = IO.read(file) unless file.nil?
+        result
       end
 
       def normalize(obj)
@@ -170,9 +199,18 @@ module Kitchen
       def parse_yaml_string(string, file_name)
         return Hash.new if string.nil? || string.empty?
 
-        ::YAML.safe_load(string) || Hash.new
+        result = SafeYAML.load(string) || Hash.new
+        unless result.is_a?(Hash)
+          raise UserError, "Error parsing #{file_name} as YAML " +
+            "(Result of parse was not a Hash, but was a #{result.class}).\n" +
+            "Please run `kitchen diagnose --no-instances --loader' to help " +
+            "debug your issue."
+        end
+        result
       rescue SyntaxError, Psych::SyntaxError
-        raise UserError, "Error parsing #{file_name}"
+        raise UserError, "Error parsing #{file_name} as YAML.\n" +
+          "Please run `kitchen diagnose --no-instances --loader' to help " +
+          "debug your issue."
       end
     end
   end

data/lib/kitchen/provisioner/base.rb

@@ -38,6 +38,11 @@ module Kitchen
         end
       end
 
+      def instance=(instance)
+        @instance = instance
+        expand_paths!
+      end
+
       # Returns the name of this driver, suitable for display in a CLI.
       #
       # @return [String] name of this driver
@@ -60,17 +65,33 @@ module Kitchen
         config.keys
       end
 
-      def install_command ; end
-
       def init_command ; end
 
-      def create_sandbox ; end
+      def install_command ; end
 
       def prepare_command ; end
 
       def run_command ; end
 
-      def cleanup_sandbox ; end
+      def create_sandbox
+        @sandbox_path = Dir.mktmpdir("#{instance.name}-sandbox-")
+        File.chmod(0755, sandbox_path)
+        info("Preparing files for transfer")
+        debug("Creating local sandbox in #{sandbox_path}")
+      end
+
+      def sandbox_path
+        @sandbox_path || (raise ClientError, "Sandbox directory has not yet " +
+          "been created. Please run #{self.class}#create_sandox before " +
+          "trying to access the path.")
+      end
+
+      def cleanup_sandbox
+        return if sandbox_path.nil?
+
+        debug("Cleaning up local sandbox in #{sandbox_path}")
+        FileUtils.rmtree(sandbox_path)
+      end
 
       # Returns a Hash of configuration and other useful diagnostic information.
       #
@@ -81,10 +102,32 @@ module Kitchen
         result
       end
 
+      def calculate_path(path, type = :directory)
+        base = config[:test_base_path]
+        candidates = []
+        candidates << File.join(base, instance.suite.name, path)
+        candidates << File.join(base, path)
+        candidates << File.join(Dir.pwd, path)
+
+        candidates.find do |c|
+          type == :directory ? File.directory?(c) : File.file?(c)
+        end
+      end
+
       protected
 
       attr_reader :config
 
+      def expand_paths!
+        expanded_paths = LazyHash.new(self.class.expanded_paths, self).to_hash
+
+        expanded_paths.each do |key, should_expand|
+          if should_expand && !config[key].nil?
+            config[key] = File.expand_path(config[key], config[:kitchen_root])
+          end
+        end
+      end
+
       def logger
         instance ? instance.logger : Kitchen.logger
       end
@@ -111,8 +154,28 @@ module Kitchen
         defaults[attr] = block_given? ? block : value
       end
 
+      def self.expanded_paths
+        @expanded_paths ||= Hash.new.merge(super_expanded_paths)
+      end
+
+      def self.super_expanded_paths
+        klass = self.superclass
+
+        if klass.respond_to?(:expanded_paths)
+          klass.expanded_paths
+        else
+          Hash.new
+        end
+      end
+
+      def self.expand_path_for(attr, value = true, &block)
+        expanded_paths[attr] = block_given? ? block : value
+      end
+
       default_config :root_path, "/tmp/kitchen"
       default_config :sudo, true
+
+      expand_path_for :test_base_path
     end
   end
 end

data/lib/kitchen/provisioner/chef_base.rb

@@ -34,7 +34,7 @@ module Kitchen
     class ChefBase < Base
 
       default_config :require_chef_omnibus, true
-      default_config :chef_omnibus_url, "https://www.opscode.com/chef/install.sh"
+      default_config :chef_omnibus_url, "https://www.getchef.com/chef/install.sh"
       default_config :run_list, []
       default_config :attributes, {}
       default_config :cookbook_files_glob, %w[README.* metadata.{json,rb}
@@ -44,31 +44,37 @@ module Kitchen
       default_config :data_path do |provisioner|
         provisioner.calculate_path("data")
       end
+      expand_path_for :data_path
 
       default_config :data_bags_path do |provisioner|
         provisioner.calculate_path("data_bags")
       end
+      expand_path_for :data_bags_path
 
       default_config :environments_path do |provisioner|
         provisioner.calculate_path("environments")
       end
+      expand_path_for :environments_path
 
       default_config :nodes_path do |provisioner|
         provisioner.calculate_path("nodes")
       end
+      expand_path_for :nodes_path
 
       default_config :roles_path do |provisioner|
         provisioner.calculate_path("roles")
       end
+      expand_path_for :roles_path
 
-      default_config :encrypted_data_bag_secret_key_path do |provisioner|
-        provisioner.calculate_path("encrypted_data_bag_secret_key", :file)
+      default_config :clients_path do |provisioner|
+        provisioner.calculate_path("clients")
       end
+      expand_path_for :clients_path
 
-      def instance=(instance)
-        @instance = instance
-        expand_paths!
+      default_config :encrypted_data_bag_secret_key_path do |provisioner|
+        provisioner.calculate_path("encrypted_data_bag_secret_key", :file)
       end
+      expand_path_for :encrypted_data_bag_secret_key_path
 
       def install_command
         return unless config[:require_chef_omnibus]
@@ -102,44 +108,27 @@ module Kitchen
       end
 
       def init_command
-        dirs = %w{cookbooks data data_bags environments roles}.
+        dirs = %w{cookbooks data data_bags environments roles clients}.
           map { |dir| File.join(config[:root_path], dir) }.join(" ")
         "#{sudo('rm')} -rf #{dirs} ; mkdir -p #{config[:root_path]}"
       end
 
-      def cleanup_sandbox
-        return if tmpdir.nil?
-
-        debug("Cleaning up local sandbox in #{tmpdir}")
-        FileUtils.rmtree(tmpdir)
-      end
-
-      def calculate_path(path, type = :directory)
-        base = config[:test_base_path]
-        candidates = []
-        candidates << File.join(base, instance.suite.name, path)
-        candidates << File.join(base, path)
-        candidates << File.join(Dir.pwd, path)
-
-        candidates.find do |c|
-          type == :directory ? File.directory?(c) : File.file?(c)
-        end
+      def create_sandbox
+        super
+        prepare_json
+        prepare_cache
+        prepare_cookbooks
+        prepare_data
+        prepare_data_bags
+        prepare_environments
+        prepare_nodes
+        prepare_roles
+        prepare_clients
+        prepare_secret
       end
 
       protected
 
-      attr_reader :tmpdir
-
-      def expand_paths!
-        paths = %w{test_base data data_bags encrypted_data_bag_secret_key
-          environments nodes roles}
-        paths.map{ |p| "#{p}_path".to_sym }.each do |key|
-          unless config[key].nil?
-            config[key] = File.expand_path(config[key], config[:kitchen_root])
-          end
-        end
-      end
-
       def format_config_file(data)
         data.each.map { |attr, value|
           [attr, (value.is_a?(Array) ? value.to_s : %{"#{value}"})].join(" ")
@@ -168,29 +157,10 @@ module Kitchen
         }
       end
 
-      def create_chef_sandbox
-        @tmpdir = Dir.mktmpdir("#{instance.name}-sandbox-")
-        File.chmod(0755, @tmpdir)
-        info("Preparing files for transfer")
-        debug("Creating local sandbox in #{tmpdir}")
-
-        yield if block_given?
-        prepare_json
-        prepare_cache
-        prepare_cookbooks
-        prepare_data
-        prepare_data_bags
-        prepare_environments
-        prepare_nodes
-        prepare_roles
-        prepare_secret
-        tmpdir
-      end
-
       def prepare_json
         dna = config[:attributes].merge({ :run_list => config[:run_list] })
 
-        File.open(File.join(tmpdir, "dna.json"), "wb") do |file|
+        File.open(File.join(sandbox_path, "dna.json"), "wb") do |file|
           file.write(dna.to_json)
         end
       end
@@ -201,7 +171,7 @@ module Kitchen
         info("Preparing data")
         debug("Using data from #{data}")
 
-        tmpdata_dir = File.join(tmpdir, "data")
+        tmpdata_dir = File.join(sandbox_path, "data")
         FileUtils.mkdir_p(tmpdata_dir)
         FileUtils.cp_r(Dir.glob("#{data}/*"), tmpdata_dir)
       end
@@ -212,7 +182,7 @@ module Kitchen
         info("Preparing data bags")
         debug("Using data bags from #{data_bags}")
 
-        tmpbags_dir = File.join(tmpdir, "data_bags")
+        tmpbags_dir = File.join(sandbox_path, "data_bags")
         FileUtils.mkdir_p(tmpbags_dir)
         FileUtils.cp_r(Dir.glob("#{data_bags}/*"), tmpbags_dir)
       end
@@ -223,18 +193,29 @@ module Kitchen
         info("Preparing roles")
         debug("Using roles from #{roles}")
 
-        tmproles_dir = File.join(tmpdir, "roles")
+        tmproles_dir = File.join(sandbox_path, "roles")
         FileUtils.mkdir_p(tmproles_dir)
         FileUtils.cp_r(Dir.glob("#{roles}/*"), tmproles_dir)
       end
 
+      def prepare_clients
+        return unless clients
+
+        info("Preparing clients")
+        debug("Using roles from #{clients}")
+
+        tmpclients_dir = File.join(sandbox_path, "clients")
+        FileUtils.mkdir_p(tmpclients_dir)
+        FileUtils.cp_r(Dir.glob("#{clients}/*"), tmpclients_dir)
+      end
+
       def prepare_nodes
         return unless nodes
 
         info("Preparing nodes")
         debug("Using nodes from #{nodes}")
 
-        tmpnodes_dir = File.join(tmpdir, "nodes")
+        tmpnodes_dir = File.join(sandbox_path, "nodes")
         FileUtils.mkdir_p(tmpnodes_dir)
         FileUtils.cp_r(Dir.glob("#{nodes}/*"), tmpnodes_dir)
       end
@@ -245,7 +226,7 @@ module Kitchen
         info("Preparing environments")
         debug("Using environments from #{environments}")
 
-        tmpenvs_dir = File.join(tmpdir, "environments")
+        tmpenvs_dir = File.join(sandbox_path, "environments")
         FileUtils.mkdir_p(tmpenvs_dir)
         FileUtils.cp_r(Dir.glob("#{environments}/*"), tmpenvs_dir)
       end
@@ -256,11 +237,11 @@ module Kitchen
         info("Preparing encrypted data bag secret")
         debug("Using secret from #{secret}")
 
-        FileUtils.cp_r(secret, File.join(tmpdir, "encrypted_data_bag_secret"))
+        FileUtils.cp_r(secret, File.join(sandbox_path, "encrypted_data_bag_secret"))
       end
 
       def prepare_cache
-        FileUtils.mkdir_p(File.join(tmpdir, "cache"))
+        FileUtils.mkdir_p(File.join(sandbox_path, "cache"))
       end
 
       def prepare_cookbooks
@@ -324,6 +305,10 @@ module Kitchen
         config[:roles_path]
       end
 
+      def clients
+        config[:clients_path]
+      end
+
       def nodes
         config[:nodes_path]
       end
@@ -341,11 +326,11 @@ module Kitchen
       end
 
       def tmpbooks_dir
-        File.join(tmpdir, "cookbooks")
+        File.join(sandbox_path, "cookbooks")
       end
 
       def tmpsitebooks_dir
-        File.join(tmpdir, "cookbooks")
+        File.join(sandbox_path, "cookbooks")
       end
 
       def cp_cookbooks