test-kitchen 1.1.1 → 1.2.0

data/lib/kitchen/provisioner/chef_solo.rb

@@ -30,7 +30,8 @@ module Kitchen
       default_config :solo_rb, {}
 
       def create_sandbox
-        create_chef_sandbox { prepare_solo_rb }
+        super
+        prepare_solo_rb
       end
 
       def run_command
@@ -48,7 +49,7 @@ module Kitchen
       def prepare_solo_rb
         data = default_config_rb.merge(config[:solo_rb])
 
-        File.open(File.join(tmpdir, "solo.rb"), "wb") do |file|
+        File.open(File.join(sandbox_path, "solo.rb"), "wb") do |file|
           file.write(format_config_file(data))
         end
       end

data/lib/kitchen/provisioner/chef_zero.rb

@@ -29,13 +29,13 @@ module Kitchen
 
       default_config :client_rb, {}
       default_config :ruby_bindir, "/opt/chef/embedded/bin"
+      default_config :json_attributes, true
 
       def create_sandbox
-        create_chef_sandbox do
-          prepare_chef_client_zero_rb
-          prepare_validation_pem
-          prepare_client_rb
-        end
+        super
+        prepare_chef_client_zero_rb
+        prepare_validation_pem
+        prepare_client_rb
       end
 
       def prepare_command
@@ -62,9 +62,11 @@ module Kitchen
       def run_command
         args = [
           "--config #{config[:root_path]}/client.rb",
-          "--json-attributes #{config[:root_path]}/dna.json",
           "--log_level #{config[:log_level]}"
         ]
+        if config[:json_attributes]
+          args << "--json-attributes #{config[:root_path]}/dna.json"
+        end
 
         if local_mode_supported?
           ["#{sudo('chef-client')} -z"].concat(args).join(" ")
@@ -84,19 +86,19 @@ module Kitchen
 
         source = File.join(File.dirname(__FILE__),
           %w{.. .. .. support chef-client-zero.rb})
-        FileUtils.cp(source, File.join(tmpdir, "chef-client-zero.rb"))
+        FileUtils.cp(source, File.join(sandbox_path, "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"))
+        FileUtils.cp(source, File.join(sandbox_path, "validation.pem"))
       end
 
       def prepare_client_rb
         data = default_config_rb.merge(config[:client_rb])
 
-        File.open(File.join(tmpdir, "client.rb"), "wb") do |file|
+        File.open(File.join(sandbox_path, "client.rb"), "wb") do |file|
           file.write(format_config_file(data))
         end
       end

data/lib/kitchen/provisioner/shell.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Chris Lundquist (<chris.lundquist@github.com>)
+#
+# Copyright (C) 2013, Chris Lundquist
+#
+# 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/provisioner/base'
+
+module Kitchen
+
+  module Provisioner
+
+    # Basic shell provisioner.
+    #
+    # @author Chris Lundquist (<chris.ludnquist@github.com>)
+    class Shell < Base
+
+      default_config :script do |provisioner|
+        provisioner.calculate_path("bootstrap.sh", :script)
+      end
+      expand_path_for :script
+
+      default_config :data_path do |provisioner|
+        provisioner.calculate_path("data")
+      end
+      expand_path_for :data_path
+
+      def create_sandbox
+        super
+        prepare_data
+        prepare_script
+      end
+
+      def init_command
+        data = File.join(config[:root_path], "data")
+        "#{sudo('rm')} -rf #{data} ; mkdir -p #{config[:root_path]}"
+      end
+
+      def run_command
+        sudo(File.join(config[:root_path], File.basename(config[:script])))
+      end
+
+      protected
+
+      def prepare_data
+        return unless config[:data_path]
+
+        info("Preparing data")
+        debug("Using data from #{config[:data_path]}")
+
+        tmpdata_dir = File.join(sandbox_path, "data")
+        FileUtils.mkdir_p(tmpdata_dir)
+        FileUtils.cp_r(Dir.glob("#{config[:data_path]}/*"), tmpdata_dir)
+      end
+
+      def prepare_script
+        info("Preparing script")
+
+        if config[:script]
+          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
+        end
+
+        FileUtils.chmod(0755,
+          File.join(sandbox_path, File.basename(config[:script])))
+      end
+    end
+  end
+end

data/lib/kitchen/state_file.rb

@@ -16,7 +16,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-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
 
@@ -86,7 +91,7 @@ module Kitchen
     end
 
     def deserialize_string(string)
-      ::YAML.safe_load(string)
+      SafeYAML.load(string)
     rescue SyntaxError, Psych::SyntaxError => ex
       raise StateFileLoadError, "Error parsing #{file_name} (#{ex.message})"
     end

data/lib/kitchen/util.rb

@@ -184,7 +184,7 @@ module Kitchen
 
         # do_download URL FILENAME
         do_download() {
-          PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
+          PATH=/opt/local/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
           export PATH
 
           echo "downloading $1"

data/lib/kitchen/version.rb

@@ -18,5 +18,5 @@
 
 module Kitchen
 
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/spec/kitchen/loader/yaml_spec.rb

@@ -28,7 +28,9 @@ end
 
 describe Kitchen::Loader::YAML do
 
-  let(:loader) { Kitchen::Loader::YAML.new("/tmp/.kitchen.yml") }
+  let(:loader) do
+    Kitchen::Loader::YAML.new(:project_config => "/tmp/.kitchen.yml")
+  end
 
   before do
     FakeFS.activate!
@@ -42,17 +44,64 @@ describe Kitchen::Loader::YAML do
 
   describe ".initialize" do
 
-    it "sets config_file based on Dir.pwd by default" do
+    it "sets project_config based on Dir.pwd by default" do
+      stub_file(File.join(Dir.pwd, '.kitchen.yml'), Hash.new)
       loader = Kitchen::Loader::YAML.new
 
-      loader.config_file.must_equal File.expand_path(
-        File.join(Dir.pwd, '.kitchen.yml'))
+      loader.diagnose[:project_config][:filename].
+        must_equal File.expand_path(File.join(Dir.pwd, '.kitchen.yml'))
     end
 
-    it "sets config_file from parameter, if given" do
-      loader = Kitchen::Loader::YAML.new('/tmp/crazyfunkytown.file')
+    it "sets project_config from parameter, if given" do
+      stub_file('/tmp/crazyfunkytown.file', Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :project_config => '/tmp/crazyfunkytown.file')
 
-      loader.config_file.must_equal '/tmp/crazyfunkytown.file'
+      loader.diagnose[:project_config][:filename].
+        must_match %r{/tmp/crazyfunkytown.file$}
+    end
+
+    it "sets local_config based on Dir.pwd by default" do
+      stub_file(File.join(Dir.pwd, '.kitchen.local.yml'), Hash.new)
+      loader = Kitchen::Loader::YAML.new
+
+      loader.diagnose[:local_config][:filename].
+        must_equal File.expand_path(File.join(Dir.pwd, '.kitchen.local.yml'))
+    end
+
+    it "sets local_config based on location of project_config by default" do
+      stub_file('/tmp/.kitchen.local.yml', Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :project_config => '/tmp/.kitchen.yml')
+
+      loader.diagnose[:local_config][:filename].
+        must_match %r{/tmp/.kitchen.local.yml$}
+    end
+
+    it "sets local_config from parameter, if given" do
+      stub_file('/tmp/crazyfunkytown.file', Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :local_config => '/tmp/crazyfunkytown.file')
+
+      loader.diagnose[:local_config][:filename].
+        must_match %r{/tmp/crazyfunkytown.file$}
+    end
+
+    it "sets global_config based on ENV['HOME'] by default" do
+      stub_file(File.join(ENV['HOME'], '.kitchen/config.yml'), Hash.new)
+      loader = Kitchen::Loader::YAML.new
+
+      loader.diagnose[:global_config][:filename].must_equal File.expand_path(
+        File.join(ENV['HOME'], '.kitchen/config.yml'))
+    end
+
+    it "sets global_config from parameter, if given" do
+      stub_file('/tmp/crazyfunkytown.file', Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :global_config => '/tmp/crazyfunkytown.file')
+
+      loader.diagnose[:global_config][:filename].
+        must_match %r{/tmp/crazyfunkytown.file$}
     end
   end
 
@@ -326,14 +375,25 @@ describe Kitchen::Loader::YAML do
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.yml", "wb") { |f| f.write '&*%^*' }
 
-      proc { loader.read }.must_raise Kitchen::UserError
+      err = proc { loader.read }.must_raise Kitchen::UserError
+      err.message.must_match Regexp.new(
+        "Error parsing ([a-zA-Z]:)?\/tmp\/\.kitchen\.yml")
     end
 
     it "raises a UserError if kitchen.yml cannot be parsed" do
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.yml", "wb") { |f| f.write 'uhoh' }
 
-      proc { loader.read }.must_raise Kitchen::UserError
+      err = proc { loader.read }.must_raise Kitchen::UserError
+      err.message.must_match Regexp.new(
+        "Error parsing ([a-zA-Z]:)?\/tmp\/\.kitchen\.yml")
+    end
+
+    it "handles a kitchen.yml if it is a commented out YAML document" do
+      FileUtils.mkdir_p "/tmp"
+      File.open("/tmp/.kitchen.yml", "wb") { |f| f.write '#---\n' }
+
+      loader.read.must_equal(Hash.new)
     end
 
     it "raises a UserError if kitchen.local.yml cannot be parsed" do
@@ -356,6 +416,20 @@ describe Kitchen::Loader::YAML do
       loader.read.must_equal({ :name => "ahhchoo" })
     end
 
+    it "raises a UserError if there is an ERB processing error" do
+      FileUtils.mkdir_p "/tmp"
+      File.open("/tmp/.kitchen.yml", "wb") do |f|
+        f.write <<-'YAML'.gsub(/^ {10}/, '')
+          ---
+          <%= poop %>: yep
+        YAML
+      end
+
+      err = proc { loader.read }.must_raise Kitchen::UserError
+      err.message.must_match Regexp.new(
+        "Error parsing ERB content in ([a-zA-Z]:)?\/tmp\/\.kitchen\.yml")
+    end
+
     it "evaluates kitchen.local.yml through erb before loading by default" do
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.local.yml", "wb") do |f|
@@ -377,7 +451,7 @@ describe Kitchen::Loader::YAML do
 
     it "skips evaluating kitchen.yml through erb if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        '/tmp/.kitchen.yml', :process_erb => false)
+        :project_config => '/tmp/.kitchen.yml', :process_erb => false)
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.yml", "wb") do |f|
         f.write <<-'YAML'.gsub(/^ {10}/, '')
@@ -391,7 +465,7 @@ describe Kitchen::Loader::YAML do
 
     it "skips evaluating kitchen.local.yml through erb if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        '/tmp/.kitchen.yml', :process_erb => false)
+        :project_config => '/tmp/.kitchen.yml', :process_erb => false)
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.local.yml", "wb") do |f|
         f.write <<-'YAML'.gsub(/^ {10}/, '')
@@ -406,7 +480,7 @@ describe Kitchen::Loader::YAML do
 
     it "skips kitchen.local.yml if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        '/tmp/.kitchen.yml', :process_local => false)
+        :project_config => '/tmp/.kitchen.yml', :process_local => false)
       stub_yaml!(".kitchen.yml", {
         'a' => 'b'
       })
@@ -419,7 +493,7 @@ describe Kitchen::Loader::YAML do
 
     it "skips the global config if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        '/tmp/.kitchen.yml', :process_global => false)
+        :project_config => '/tmp/.kitchen.yml', :process_global => false)
       stub_yaml!(".kitchen.yml", {
         'a' => 'b'
       })
@@ -431,6 +505,246 @@ describe Kitchen::Loader::YAML do
     end
   end
 
+  describe "#diagnose" do
+
+    it "returns a Hash" do
+      stub_yaml!(Hash.new)
+
+      loader.diagnose.must_be_kind_of(Hash)
+    end
+
+    it "contains erb processing information when true" do
+      stub_yaml!(Hash.new)
+
+      loader.diagnose[:process_erb].must_equal true
+    end
+
+    it "contains erb processing information when false" do
+      stub_yaml!(Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :project_config => '/tmp/.kitchen.yml', :process_erb => false)
+
+      loader.diagnose[:process_erb].must_equal false
+    end
+
+    it "contains local processing information when true" do
+      stub_yaml!(Hash.new)
+
+      loader.diagnose[:process_local].must_equal true
+    end
+
+    it "contains local processing information when false" do
+      stub_yaml!(Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :project_config => '/tmp/.kitchen.yml', :process_local => false)
+
+      loader.diagnose[:process_local].must_equal false
+    end
+
+    it "contains global processing information when true" do
+      stub_yaml!(Hash.new)
+
+      loader.diagnose[:process_global].must_equal true
+    end
+
+    it "contains global processing information when false" do
+      stub_yaml!(Hash.new)
+      loader = Kitchen::Loader::YAML.new(
+        :project_config => '/tmp/.kitchen.yml', :process_global => false)
+
+      loader.diagnose[:process_global].must_equal false
+    end
+
+    describe "for yaml files" do
+
+      before do
+        stub_yaml!(".kitchen.yml", {
+          "from_project" => "project",
+          "common" => { "p" => "pretty" }
+        })
+        stub_yaml!(".kitchen.local.yml", {
+          "from_local" => "local",
+          "common" => { "l" => "looky" }
+        })
+        stub_global!({
+          "from_global" => "global",
+          "common" => { "g" => "goody" }
+        })
+      end
+
+      it "global config contains a filename" do
+        loader.diagnose[:global_config][:filename].
+          must_equal File.join(ENV["HOME"], ".kitchen/config.yml")
+      end
+
+      it "global config contains raw data" do
+        loader.diagnose[:global_config][:raw_data].must_equal({
+          "from_global" => "global",
+          "common" => { "g" => "goody" }
+        })
+      end
+
+      it "project config contains a filename" do
+        loader.diagnose[:project_config][:filename].
+          must_match %r{/tmp/.kitchen.yml$}
+      end
+
+      it "project config contains raw data" do
+        loader.diagnose[:project_config][:raw_data].must_equal({
+          "from_project" => "project",
+          "common" => { "p" => "pretty" }
+        })
+      end
+
+      it "local config contains a filename" do
+        loader.diagnose[:local_config][:filename].
+          must_match %r{/tmp/.kitchen.local.yml$}
+      end
+
+      it "local config contains raw data" do
+        loader.diagnose[:local_config][:raw_data].must_equal({
+          "from_local" => "local",
+          "common" => { "l" => "looky" }
+        })
+      end
+
+      it "combined config contains a nil filename" do
+        loader.diagnose[:combined_config][:filename].
+          must_equal nil
+      end
+
+      it "combined config contains raw data" do
+        loader.diagnose[:combined_config][:raw_data].must_equal({
+          "from_global" => "global",
+          "from_project" => "project",
+          "from_local" => "local",
+          "common" => {
+            "g" => "goody",
+            "p" => "pretty",
+            "l" => "looky"
+          }
+        })
+      end
+
+      describe "for global on error" do
+
+        before do
+          FileUtils.mkdir_p(File.join(ENV["HOME"], ".kitchen"))
+          File.open(File.join(ENV["HOME"], ".kitchen/config.yml"), "wb") do |f|
+            f.write '&*%^*'
+          end
+        end
+
+        it "uses an error hash with the raw file contents" do
+          loader.diagnose[:global_config][:raw_data][:error][:raw_file].
+            must_equal "&*%^*"
+        end
+
+        it "uses an error hash with the exception" do
+          loader.diagnose[:global_config][:raw_data][:error][:exception].
+            must_match %r{Kitchen::UserError}
+        end
+
+        it "uses an error hash with the exception message" do
+          loader.diagnose[:global_config][:raw_data][:error][:message].
+            must_match %r{Error parsing}
+        end
+
+        it "uses an error hash with the exception backtrace" do
+          loader.diagnose[:global_config][:raw_data][:error][:backtrace].
+            must_be_kind_of Array
+        end
+      end
+
+      describe "for project on error" do
+
+        before do
+          File.open("/tmp/.kitchen.yml", "wb") do |f|
+            f.write '&*%^*'
+          end
+        end
+
+        it "uses an error hash with the raw file contents" do
+          loader.diagnose[:project_config][:raw_data][:error][:raw_file].
+            must_equal "&*%^*"
+        end
+
+        it "uses an error hash with the exception" do
+          loader.diagnose[:project_config][:raw_data][:error][:exception].
+            must_match %r{Kitchen::UserError}
+        end
+
+        it "uses an error hash with the exception message" do
+          loader.diagnose[:project_config][:raw_data][:error][:message].
+            must_match %r{Error parsing}
+        end
+
+        it "uses an error hash with the exception backtrace" do
+          loader.diagnose[:project_config][:raw_data][:error][:backtrace].
+            must_be_kind_of Array
+        end
+      end
+
+      describe "for local on error" do
+
+        before do
+          File.open("/tmp/.kitchen.local.yml", "wb") do |f|
+            f.write '&*%^*'
+          end
+        end
+
+        it "uses an error hash with the raw file contents" do
+          loader.diagnose[:local_config][:raw_data][:error][:raw_file].
+            must_equal "&*%^*"
+        end
+
+        it "uses an error hash with the exception" do
+          loader.diagnose[:local_config][:raw_data][:error][:exception].
+            must_match %r{Kitchen::UserError}
+        end
+
+        it "uses an error hash with the exception message" do
+          loader.diagnose[:local_config][:raw_data][:error][:message].
+            must_match %r{Error parsing}
+        end
+
+        it "uses an error hash with the exception backtrace" do
+          loader.diagnose[:local_config][:raw_data][:error][:backtrace].
+            must_be_kind_of Array
+        end
+      end
+
+      describe "for combined on error" do
+
+        before do
+          File.open("/tmp/.kitchen.yml", "wb") do |f|
+            f.write '&*%^*'
+          end
+        end
+
+        it "uses an error hash with nil raw file contents" do
+          loader.diagnose[:combined_config][:raw_data][:error][:raw_file].
+            must_equal nil
+        end
+
+        it "uses an error hash with the exception" do
+          loader.diagnose[:combined_config][:raw_data][:error][:exception].
+            must_match %r{Kitchen::UserError}
+        end
+
+        it "uses an error hash with the exception message" do
+          loader.diagnose[:combined_config][:raw_data][:error][:message].
+            must_match %r{Error parsing}
+        end
+
+        it "uses an error hash with the exception backtrace" do
+          loader.diagnose[:combined_config][:raw_data][:error][:backtrace].
+            must_be_kind_of Array
+        end
+      end
+    end
+  end
+
   private
 
   def stub_file(path, hash)