test-kitchen 1.2.1 → 1.3.0

data/spec/kitchen/lazy_hash_spec.rb

@@ -16,9 +16,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative '../spec_helper'
+require_relative "../spec_helper"
 
-require 'kitchen/lazy_hash'
+require "kitchen/lazy_hash"
 
 describe Kitchen::LazyHash do
 
@@ -26,33 +26,60 @@ describe Kitchen::LazyHash do
     stub(:color => "blue", :metal => "heavy")
   end
 
-  let(:hash) do
+  let(:hash_obj) do
     {
-      :shed_color => lambda { |c| c.color },
+      :shed_color => ->(c) { c.color },
       :barn => "locked",
-      :genre => Proc.new { |c| "#{c.metal} metal"}
+      :genre => proc { |c| "#{c.metal} metal" }
     }
   end
 
   describe "#[]" do
 
     it "returns regular values for keys" do
-      Kitchen::LazyHash.new(hash, context)[:barn].must_equal "locked"
+      Kitchen::LazyHash.new(hash_obj, context)[:barn].must_equal "locked"
     end
 
     it "invokes call on values that are lambdas" do
-      Kitchen::LazyHash.new(hash, context)[:shed_color].must_equal "blue"
+      Kitchen::LazyHash.new(hash_obj, context)[:shed_color].must_equal "blue"
     end
 
     it "invokes call on values that are Procs" do
-      Kitchen::LazyHash.new(hash, context)[:genre].must_equal "heavy metal"
+      Kitchen::LazyHash.new(hash_obj, context)[:genre].must_equal "heavy metal"
+    end
+  end
+
+  describe "#fetch" do
+
+    it "returns regular hash values for keys" do
+      Kitchen::LazyHash.new(hash_obj, context).fetch(:barn).must_equal "locked"
+    end
+
+    it "invokes call on values that are lambdas" do
+      Kitchen::LazyHash.new(hash_obj, context).
+        fetch(:shed_color).must_equal "blue"
+    end
+
+    it "invokes call on values that are Procs" do
+      Kitchen::LazyHash.new(hash_obj, context).
+        fetch(:genre).must_equal "heavy metal"
+    end
+
+    it "uses a default value for unset values" do
+      Kitchen::LazyHash.new(hash_obj, context).
+        fetch(:nope, "candy").must_equal "candy"
+    end
+
+    it "uses a block for unset values" do
+      Kitchen::LazyHash.new(hash_obj, context).
+        fetch(:nope) { |key| "#{key} is costly" }.must_equal "nope is costly"
     end
   end
 
   describe "#to_hash" do
 
     it "invokes any callable values and returns a Hash object" do
-      converted = Kitchen::LazyHash.new(hash, context).to_hash
+      converted = Kitchen::LazyHash.new(hash_obj, context).to_hash
 
       converted.must_be_instance_of Hash
       converted.fetch(:shed_color).must_equal "blue"

data/spec/kitchen/loader/yaml_spec.rb

@@ -16,11 +16,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative '../../spec_helper'
+require_relative "../../spec_helper"
 
-require 'kitchen/errors'
-require 'kitchen/util'
-require 'kitchen/loader/yaml'
+require "kitchen/errors"
+require "kitchen/util"
+require "kitchen/loader/yaml"
 
 class Yamled
   attr_accessor :foo
@@ -45,60 +45,60 @@ describe Kitchen::Loader::YAML do
   describe ".initialize" do
 
     it "sets project_config based on Dir.pwd by default" do
-      stub_file(File.join(Dir.pwd, '.kitchen.yml'), Hash.new)
+      stub_file(File.join(Dir.pwd, ".kitchen.yml"), Hash.new)
       loader = Kitchen::Loader::YAML.new
 
       loader.diagnose[:project_config][:filename].
-        must_equal File.expand_path(File.join(Dir.pwd, '.kitchen.yml'))
+        must_equal File.expand_path(File.join(Dir.pwd, ".kitchen.yml"))
     end
 
     it "sets project_config from parameter, if given" do
-      stub_file('/tmp/crazyfunkytown.file', Hash.new)
+      stub_file("/tmp/crazyfunkytown.file", Hash.new)
       loader = Kitchen::Loader::YAML.new(
-        :project_config => '/tmp/crazyfunkytown.file')
+        :project_config => "/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)
+      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'))
+        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)
+      stub_file("/tmp/.kitchen.local.yml", Hash.new)
       loader = Kitchen::Loader::YAML.new(
-        :project_config => '/tmp/.kitchen.yml')
+        :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)
+      stub_file("/tmp/crazyfunkytown.file", Hash.new)
       loader = Kitchen::Loader::YAML.new(
-        :local_config => '/tmp/crazyfunkytown.file')
+        :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)
+      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'))
+        File.join(ENV["HOME"], ".kitchen/config.yml"))
     end
 
     it "sets global_config from parameter, if given" do
-      stub_file('/tmp/crazyfunkytown.file', Hash.new)
+      stub_file("/tmp/crazyfunkytown.file", Hash.new)
       loader = Kitchen::Loader::YAML.new(
-        :global_config => '/tmp/crazyfunkytown.file')
+        :global_config => "/tmp/crazyfunkytown.file")
 
       loader.diagnose[:global_config][:filename].
         must_match %r{/tmp/crazyfunkytown.file$}
@@ -108,75 +108,86 @@ describe Kitchen::Loader::YAML do
   describe "#read" do
 
     it "returns a hash of kitchen.yml with symbolized keys" do
-      stub_yaml!({
-        'foo' => 'bar'
-      })
+      stub_yaml!(
+        "foo" => "bar"
+      )
 
-      loader.read.must_equal({ :foo => 'bar' })
+      loader.read.must_equal(:foo => "bar")
     end
 
     it "deep merges in kitchen.local.yml configuration with kitchen.yml" do
-      stub_yaml!(".kitchen.yml", {
-        'common' => { 'xx' => 1 },
-        'a' => 'b'
-      })
-      stub_yaml!(".kitchen.local.yml", {
-        'common' => { 'yy' => 2 },
-        'c' => 'd'
-      })
-
-      loader.read.must_equal({
-        :a => 'b',
-        :c => 'd',
+      stub_yaml!(".kitchen.yml",
+        "common" => { "xx" => 1 },
+        "a" => "b"
+      )
+      stub_yaml!(".kitchen.local.yml",
+        "common" => { "yy" => 2 },
+        "c" => "d"
+      )
+
+      loader.read.must_equal(
+        :a => "b",
+        :c => "d",
         :common => { :xx => 1, :yy => 2 }
-      })
+      )
     end
 
     it "deep merges in a global config file with all other configs" do
-      stub_yaml!(".kitchen.yml", {
-        'common' => { 'xx' => 1 },
-        'a' => 'b'
-      })
-      stub_yaml!(".kitchen.local.yml", {
-        'common' => { 'yy' => 2 },
-        'c' => 'd'
-      })
-      stub_global!({
-        'common' => { 'zz' => 3 },
-        'e' => 'f'
-      })
-
-      loader.read.must_equal({
-        :a => 'b',
-        :c => 'd',
-        :e => 'f',
+      stub_yaml!(".kitchen.yml",
+        "common" => { "xx" => 1 },
+        "a" => "b"
+      )
+      stub_yaml!(".kitchen.local.yml",
+        "common" => { "yy" => 2 },
+        "c" => "d"
+      )
+      stub_global!(
+        "common" => { "zz" => 3 },
+        "e" => "f"
+      )
+
+      loader.read.must_equal(
+        :a => "b",
+        :c => "d",
+        :e => "f",
         :common => { :xx => 1, :yy => 2, :zz => 3 }
-      })
+      )
+    end
+
+    it "merges kitchen.yml over configuration in global config" do
+      stub_global!(
+        "common" => { "thekey" => "nope" }
+      )
+      stub_yaml!(".kitchen.yml",
+        "common" => { "thekey" => "yep" }
+      )
+
+      loader.read.must_equal(:common => { :thekey => "yep" })
     end
 
     it "merges kitchen.local.yml over configuration in kitchen.yml" do
-      stub_yaml!(".kitchen.yml", {
-        'common' => { 'thekey' => 'nope' }
-      })
-      stub_yaml!(".kitchen.local.yml", {
-        'common' => { 'thekey' => 'yep' }
-      })
+      stub_yaml!(".kitchen.yml",
+        "common" => { "thekey" => "nope" }
+      )
+      stub_yaml!(".kitchen.local.yml",
+        "common" => { "thekey" => "yep" }
+      )
 
-      loader.read.must_equal({ :common => { :thekey => 'yep' } })
+      loader.read.must_equal(:common => { :thekey => "yep" })
     end
 
-    it "merges global config over both kitchen.local.yml and kitchen.yml" do
-      stub_yaml!(".kitchen.yml", {
-        'common' => { 'thekey' => 'nope' }
-      })
-      stub_yaml!(".kitchen.local.yml", {
-        'common' => { 'thekey' => 'yep' }
-      })
-      stub_global!({
-        'common' => { 'thekey' => 'kinda' }
-      })
+    it "merges kitchen.local.yml over both kitchen.yml and global config" do
+      stub_yaml!(".kitchen.yml",
+        "common" => { "thekey" => "nope" }
+      )
+      stub_yaml!(".kitchen.local.yml",
+        "common" => { "thekey" => "yep" }
+      )
+      stub_global!(
+        "common" => { "thekey" => "kinda" }
+      )
 
-      loader.read.must_equal({ :common => { :thekey => 'kinda' } })
+      loader.read.must_equal(:common => { :thekey => "yep" })
     end
 
     NORMALIZED_KEYS = {
@@ -190,152 +201,152 @@ describe Kitchen::Loader::YAML do
       describe "normalizing #{key} config hashes" do
 
         it "merges local with #{key} string value over yaml with hash value" do
-          stub_yaml!(".kitchen.yml", {
-            key => { 'dakey' => 'ya' }
-          })
-          stub_yaml!(".kitchen.local.yml", {
-            key => 'namey'
-          })
-
-          loader.read.must_equal({
-            key.to_sym => { default_key.to_sym => "namey", :dakey => 'ya' }
-          })
+          stub_yaml!(".kitchen.yml",
+            key => { "dakey" => "ya" }
+          )
+          stub_yaml!(".kitchen.local.yml",
+            key => "namey"
+          )
+
+          loader.read.must_equal(
+            key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
+          )
         end
 
         it "merges local with #{key} hash value over yaml with string value" do
-          stub_yaml!(".kitchen.yml", {
-            key => 'namey'
-          })
-          stub_yaml!(".kitchen.local.yml", {
-            key => { 'dakey' => 'ya' }
-          })
-
-          loader.read.must_equal({
-            key.to_sym => { default_key.to_sym => "namey", :dakey => 'ya' }
-          })
+          stub_yaml!(".kitchen.yml",
+            key => "namey"
+          )
+          stub_yaml!(".kitchen.local.yml",
+            key => { "dakey" => "ya" }
+          )
+
+          loader.read.must_equal(
+            key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
+          )
         end
 
         it "merges local with #{key} nil value over yaml with hash value" do
-          stub_yaml!(".kitchen.yml", {
-            key => { 'dakey' => 'ya' }
-          })
-          stub_yaml!(".kitchen.local.yml", {
+          stub_yaml!(".kitchen.yml",
+            key => { "dakey" => "ya" }
+          )
+          stub_yaml!(".kitchen.local.yml",
             key => nil
-          })
+          )
 
-          loader.read.must_equal({
-            key.to_sym => { :dakey => 'ya' }
-          })
+          loader.read.must_equal(
+            key.to_sym => { :dakey => "ya" }
+          )
         end
 
         it "merges local with #{key} hash value over yaml with nil value" do
-          stub_yaml!(".kitchen.yml", {
-            key => 'namey'
-          })
-          stub_yaml!(".kitchen.local.yml", {
+          stub_yaml!(".kitchen.yml",
+            key => "namey"
+          )
+          stub_yaml!(".kitchen.local.yml",
             key => nil
-          })
+          )
 
-          loader.read.must_equal({
+          loader.read.must_equal(
             key.to_sym => { default_key.to_sym => "namey" }
-          })
+          )
         end
 
         it "merges global with #{key} string value over yaml with hash value" do
-          stub_yaml!(".kitchen.yml", {
-            key => { 'dakey' => 'ya' }
-          })
-          stub_global!({
-            key => 'namey'
-          })
-
-          loader.read.must_equal({
-            key.to_sym => { default_key.to_sym => "namey", :dakey => 'ya' }
-          })
+          stub_yaml!(".kitchen.yml",
+            key => { "dakey" => "ya" }
+          )
+          stub_global!(
+            key => "namey"
+          )
+
+          loader.read.must_equal(
+            key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
+          )
         end
 
         it "merges global with #{key} hash value over yaml with string value" do
-          stub_yaml!(".kitchen.yml", {
-            key => 'namey'
-          })
-          stub_global!({
-            key => { 'dakey' => 'ya' }
-          })
-
-          loader.read.must_equal({
-            key.to_sym => { default_key.to_sym => "namey", :dakey => 'ya' }
-          })
+          stub_yaml!(".kitchen.yml",
+            key => "namey"
+          )
+          stub_global!(
+            key => { "dakey" => "ya" }
+          )
+
+          loader.read.must_equal(
+            key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
+          )
         end
 
         it "merges global with #{key} nil value over yaml with hash value" do
-          stub_yaml!(".kitchen.yml", {
-            key => { 'dakey' => 'ya' }
-          })
-          stub_global!({
+          stub_yaml!(".kitchen.yml",
+            key => { "dakey" => "ya" }
+          )
+          stub_global!(
             key => nil
-          })
+          )
 
-          loader.read.must_equal({
-            key.to_sym => { :dakey => 'ya' }
-          })
+          loader.read.must_equal(
+            key.to_sym => { :dakey => "ya" }
+          )
         end
 
         it "merges global with #{key} hash value over yaml with nil value" do
-          stub_yaml!(".kitchen.yml", {
+          stub_yaml!(".kitchen.yml",
             key => nil
-          })
-          stub_global!({
-            key => { 'dakey' => 'ya' }
-          })
-
-          loader.read.must_equal({
-            key.to_sym => { :dakey => 'ya' }
-          })
+          )
+          stub_global!(
+            key => { "dakey" => "ya" }
+          )
+
+          loader.read.must_equal(
+            key.to_sym => { :dakey => "ya" }
+          )
         end
 
         it "merges global, local, over yaml with mixed hash, string, nil values" do
-          stub_yaml!(".kitchen.yml", {
+          stub_yaml!(".kitchen.yml",
             key => nil
-          })
-          stub_yaml!(".kitchen.local.yml", {
+          )
+          stub_yaml!(".kitchen.local.yml",
             key => "namey"
-          })
-          stub_global!({
-            key => { 'dakey' => 'ya' }
-          })
-
-          loader.read.must_equal({
-            key.to_sym => { default_key.to_sym => "namey", :dakey => 'ya' }
-          })
+          )
+          stub_global!(
+            key => { "dakey" => "ya" }
+          )
+
+          loader.read.must_equal(
+            key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
+          )
         end
       end
     end
 
     it "handles a kitchen.local.yml with no yaml elements" do
-      stub_yaml!(".kitchen.yml", {
-        'a' => 'b'
-      })
+      stub_yaml!(".kitchen.yml",
+        "a" => "b"
+      )
       stub_yaml!(".kitchen.local.yml", Hash.new)
 
-      loader.read.must_equal({ :a => 'b' })
+      loader.read.must_equal(:a => "b")
     end
 
     it "handles a kitchen.yml with no yaml elements" do
       stub_yaml!(".kitchen.yml", Hash.new)
-      stub_yaml!(".kitchen.local.yml", {
-        'a' => 'b'
-      })
+      stub_yaml!(".kitchen.local.yml",
+        "a" => "b"
+      )
 
-      loader.read.must_equal({ :a => 'b' })
+      loader.read.must_equal(:a => "b")
     end
 
     it "handles a kitchen.yml with yaml elements that parse as nil" do
       stub_yaml!(".kitchen.yml", nil)
-      stub_yaml!(".kitchen.local.yml", {
-        'a' => 'b'
-      })
+      stub_yaml!(".kitchen.local.yml",
+        "a" => "b"
+      )
 
-      loader.read.must_equal({ :a => 'b' })
+      loader.read.must_equal(:a => "b")
     end
 
     it "raises an UserError if the config_file does not exist" do
@@ -345,7 +356,7 @@ describe Kitchen::Loader::YAML do
     it "arbitrary objects aren't deserialized in kitchen.yml" do
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.yml", "wb") do |f|
-        f.write <<-YAML.gsub(/^ {10}/, '')
+        f.write <<-YAML.gsub(/^ {10}/, "")
           --- !ruby/object:Yamled
           foo: bar
         YAML
@@ -353,13 +364,13 @@ describe Kitchen::Loader::YAML do
 
       loader.read.class.wont_equal Yamled
       loader.read.class.must_equal Hash
-      loader.read.must_equal({ :foo => 'bar' })
+      loader.read.must_equal(:foo => "bar")
     end
 
     it "arbitrary objects aren't deserialized in kitchen.local.yml" do
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.local.yml", "wb") do |f|
-        f.write <<-YAML.gsub(/^ {10}/, '')
+        f.write <<-YAML.gsub(/^ {10}/, "")
           --- !ruby/object:Yamled
           wakka: boop
         YAML
@@ -368,12 +379,12 @@ describe Kitchen::Loader::YAML do
 
       loader.read.class.wont_equal Yamled
       loader.read.class.must_equal Hash
-      loader.read.must_equal({ :wakka => 'boop' })
+      loader.read.must_equal(:wakka => "boop")
     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 '&*%^*' }
+      File.open("/tmp/.kitchen.yml", "wb") { |f| f.write "&*%^*" }
 
       err = proc { loader.read }.must_raise Kitchen::UserError
       err.message.must_match Regexp.new(
@@ -382,7 +393,7 @@ describe Kitchen::Loader::YAML do
 
     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' }
+      File.open("/tmp/.kitchen.yml", "wb") { |f| f.write "uhoh" }
 
       err = proc { loader.read }.must_raise Kitchen::UserError
       err.message.must_match Regexp.new(
@@ -398,7 +409,7 @@ describe Kitchen::Loader::YAML do
 
     it "raises a UserError if kitchen.local.yml cannot be parsed" do
       FileUtils.mkdir_p "/tmp"
-      File.open("/tmp/.kitchen.local.yml", "wb") { |f| f.write '&*%^*' }
+      File.open("/tmp/.kitchen.local.yml", "wb") { |f| f.write "&*%^*" }
       stub_yaml!(".kitchen.yml", Hash.new)
 
       proc { loader.read }.must_raise Kitchen::UserError
@@ -407,19 +418,19 @@ describe Kitchen::Loader::YAML do
     it "evaluates kitchen.yml through erb before loading by default" do
       FileUtils.mkdir_p "/tmp"
       File.open("/tmp/.kitchen.yml", "wb") do |f|
-        f.write <<-'YAML'.gsub(/^ {10}/, '')
+        f.write <<-'YAML'.gsub(/^ {10}/, "")
           ---
           name: <%= "AHH".downcase + "choo" %>
         YAML
       end
 
-      loader.read.must_equal({ :name => "ahhchoo" })
+      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}/, '')
+        f.write <<-'YAML'.gsub(/^ {10}/, "")
           ---
           <%= poop %>: yep
         YAML
@@ -433,75 +444,75 @@ describe Kitchen::Loader::YAML do
     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|
-        f.write <<-'YAML'.gsub(/^ {10}/, '')
+        f.write <<-'YAML'.gsub(/^ {10}/, "")
           ---
           <% %w{noodle mushroom}.each do |kind| %>
             <%= kind %>: soup
           <% end %>
         YAML
       end
-      stub_yaml!(".kitchen.yml", { 'spinach' => 'salad' })
+      stub_yaml!(".kitchen.yml", "spinach" => "salad")
 
-      loader.read.must_equal({
-        :spinach => 'salad',
-        :noodle => 'soup',
-        :mushroom => 'soup'
-      })
+      loader.read.must_equal(
+        :spinach => "salad",
+        :noodle => "soup",
+        :mushroom => "soup"
+      )
     end
 
     it "skips evaluating kitchen.yml through erb if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        :project_config => '/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}/, '')
+        f.write <<-'YAML'.gsub(/^ {10}/, "")
           ---
           name: <%= "AHH".downcase %>
         YAML
       end
 
-      loader.read.must_equal({ :name => '<%= "AHH".downcase %>' })
+      loader.read.must_equal(:name => '<%= "AHH".downcase %>')
     end
 
     it "skips evaluating kitchen.local.yml through erb if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        :project_config => '/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}/, '')
+        f.write <<-'YAML'.gsub(/^ {10}/, "")
           ---
           name: <%= "AHH".downcase %>
         YAML
       end
       stub_yaml!(".kitchen.yml", Hash.new)
 
-      loader.read.must_equal({ :name => '<%= "AHH".downcase %>' })
+      loader.read.must_equal(:name => '<%= "AHH".downcase %>')
     end
 
     it "skips kitchen.local.yml if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        :project_config => '/tmp/.kitchen.yml', :process_local => false)
-      stub_yaml!(".kitchen.yml", {
-        'a' => 'b'
-      })
-      stub_yaml!(".kitchen.local.yml", {
-        'superawesomesauceadditions' => 'enabled, yo'
-      })
+        :project_config => "/tmp/.kitchen.yml", :process_local => false)
+      stub_yaml!(".kitchen.yml",
+        "a" => "b"
+      )
+      stub_yaml!(".kitchen.local.yml",
+        "superawesomesauceadditions" => "enabled, yo"
+      )
 
-      loader.read.must_equal({ :a => 'b' })
+      loader.read.must_equal(:a => "b")
     end
 
     it "skips the global config if disabled" do
       loader = Kitchen::Loader::YAML.new(
-        :project_config => '/tmp/.kitchen.yml', :process_global => false)
-      stub_yaml!(".kitchen.yml", {
-        'a' => 'b'
-      })
-      stub_global!({
-        'superawesomesauceadditions' => 'enabled, yo'
-      })
+        :project_config => "/tmp/.kitchen.yml", :process_global => false)
+      stub_yaml!(".kitchen.yml",
+        "a" => "b"
+      )
+      stub_global!(
+        "superawesomesauceadditions" => "enabled, yo"
+      )
 
-      loader.read.must_equal({ :a => 'b' })
+      loader.read.must_equal(:a => "b")
     end
   end
 
@@ -522,7 +533,7 @@ describe Kitchen::Loader::YAML do
     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)
+        :project_config => "/tmp/.kitchen.yml", :process_erb => false)
 
       loader.diagnose[:process_erb].must_equal false
     end
@@ -536,7 +547,7 @@ describe Kitchen::Loader::YAML do
     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)
+        :project_config => "/tmp/.kitchen.yml", :process_local => false)
 
       loader.diagnose[:process_local].must_equal false
     end
@@ -550,7 +561,7 @@ describe Kitchen::Loader::YAML do
     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)
+        :project_config => "/tmp/.kitchen.yml", :process_global => false)
 
       loader.diagnose[:process_global].must_equal false
     end
@@ -558,18 +569,18 @@ describe Kitchen::Loader::YAML do
     describe "for yaml files" do
 
       before do
-        stub_yaml!(".kitchen.yml", {
+        stub_yaml!(".kitchen.yml",
           "from_project" => "project",
           "common" => { "p" => "pretty" }
-        })
-        stub_yaml!(".kitchen.local.yml", {
+        )
+        stub_yaml!(".kitchen.local.yml",
           "from_local" => "local",
           "common" => { "l" => "looky" }
-        })
-        stub_global!({
+        )
+        stub_global!(
           "from_global" => "global",
           "common" => { "g" => "goody" }
-        })
+        )
       end
 
       it "global config contains a filename" do
@@ -578,10 +589,10 @@ describe Kitchen::Loader::YAML do
       end
 
       it "global config contains raw data" do
-        loader.diagnose[:global_config][:raw_data].must_equal({
+        loader.diagnose[:global_config][:raw_data].must_equal(
           "from_global" => "global",
           "common" => { "g" => "goody" }
-        })
+        )
       end
 
       it "project config contains a filename" do
@@ -590,10 +601,10 @@ describe Kitchen::Loader::YAML do
       end
 
       it "project config contains raw data" do
-        loader.diagnose[:project_config][:raw_data].must_equal({
+        loader.diagnose[:project_config][:raw_data].must_equal(
           "from_project" => "project",
           "common" => { "p" => "pretty" }
-        })
+        )
       end
 
       it "local config contains a filename" do
@@ -602,10 +613,10 @@ describe Kitchen::Loader::YAML do
       end
 
       it "local config contains raw data" do
-        loader.diagnose[:local_config][:raw_data].must_equal({
+        loader.diagnose[:local_config][:raw_data].must_equal(
           "from_local" => "local",
           "common" => { "l" => "looky" }
-        })
+        )
       end
 
       it "combined config contains a nil filename" do
@@ -614,7 +625,7 @@ describe Kitchen::Loader::YAML do
       end
 
       it "combined config contains raw data" do
-        loader.diagnose[:combined_config][:raw_data].must_equal({
+        loader.diagnose[:combined_config][:raw_data].must_equal(
           "from_global" => "global",
           "from_project" => "project",
           "from_local" => "local",
@@ -623,7 +634,7 @@ describe Kitchen::Loader::YAML do
             "p" => "pretty",
             "l" => "looky"
           }
-        })
+        )
       end
 
       describe "for global on error" do
@@ -631,7 +642,7 @@ describe Kitchen::Loader::YAML 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 '&*%^*'
+            f.write "&*%^*"
           end
         end
 
@@ -660,7 +671,7 @@ describe Kitchen::Loader::YAML do
 
         before do
           File.open("/tmp/.kitchen.yml", "wb") do |f|
-            f.write '&*%^*'
+            f.write "&*%^*"
           end
         end
 
@@ -689,7 +700,7 @@ describe Kitchen::Loader::YAML do
 
         before do
           File.open("/tmp/.kitchen.local.yml", "wb") do |f|
-            f.write '&*%^*'
+            f.write "&*%^*"
           end
         end
 
@@ -718,7 +729,7 @@ describe Kitchen::Loader::YAML do
 
         before do
           File.open("/tmp/.kitchen.yml", "wb") do |f|
-            f.write '&*%^*'
+            f.write "&*%^*"
           end
         end