test-kitchen 1.14.1 → 1.14.2

data/spec/kitchen/lazy_hash_spec.rb

@@ -21,21 +21,19 @@ require_relative "../spec_helper"
 require "kitchen/lazy_hash"
 
 describe Kitchen::LazyHash do
-
   let(:context) do
-    stub(:color => "blue", :metal => "heavy")
+    stub(color: "blue", metal: "heavy")
   end
 
   let(:hash_obj) do
     {
-      :shed_color => ->(c) { c.color },
-      :barn => "locked",
-      :genre => proc { |c| "#{c.metal} metal" }
+      shed_color: ->(c) { c.color },
+      barn: "locked",
+      genre: proc { |c| "#{c.metal} metal" },
     }
   end
 
   describe "#[]" do
-
     it "returns regular values for keys" do
       Kitchen::LazyHash.new(hash_obj, context)[:barn].must_equal "locked"
     end
@@ -50,34 +48,32 @@ describe Kitchen::LazyHash do
   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"
+      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"
+      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"
+      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"
+      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_obj, context).to_hash
 
@@ -90,8 +86,8 @@ describe Kitchen::LazyHash do
 
   describe "select" do
     it "calls Procs when appropriate" do
-      Kitchen::LazyHash.new(hash_obj, context).select { |_, _| true }.
-        must_equal :shed_color => "blue", :barn => "locked", :genre => "heavy metal"
+      Kitchen::LazyHash.new(hash_obj, context).select { |_, _| true }
+                       .must_equal shed_color: "blue", barn: "locked", genre: "heavy metal"
     end
   end
 

data/spec/kitchen/loader/yaml_spec.rb

@@ -27,9 +27,8 @@ class Yamled
 end
 
 describe Kitchen::Loader::YAML do
-
   let(:loader) do
-    Kitchen::Loader::YAML.new(:project_config => "/tmp/.kitchen.yml")
+    Kitchen::Loader::YAML.new(project_config: "/tmp/.kitchen.yml")
   end
 
   before do
@@ -43,52 +42,51 @@ describe Kitchen::Loader::YAML do
   end
 
   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"), {})
       loader = Kitchen::Loader::YAML.new
 
-      loader.diagnose[:project_config][:filename].
-        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 project_config from parameter, if given" do
-      stub_file("/tmp/crazyfunkytown.file", Hash.new)
+      stub_file("/tmp/crazyfunkytown.file", {})
       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$}
+      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"), {})
       loader = Kitchen::Loader::YAML.new
 
-      loader.diagnose[:local_config][:filename].
-        must_equal File.expand_path(File.join(Dir.pwd, ".kitchen.local.yml"))
+      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)
+      stub_file("/tmp/.kitchen.local.yml", {})
       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$}
+      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", {})
       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$}
+      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"), {})
       loader = Kitchen::Loader::YAML.new
 
       loader.diagnose[:global_config][:filename].must_equal File.expand_path(
@@ -96,61 +94,64 @@ describe Kitchen::Loader::YAML do
     end
 
     it "sets global_config from parameter, if given" do
-      stub_file("/tmp/crazyfunkytown.file", Hash.new)
+      stub_file("/tmp/crazyfunkytown.file", {})
       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$}
+      loader.diagnose[:global_config][:filename]
+        .must_match %r{/tmp/crazyfunkytown.file$}
     end
   end
 
   describe "#read" do
-
     it "returns a hash of kitchen.yml with symbolized keys" do
       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"
-      )
+      stub_yaml!("common" => { "xx" => 1 },
+                 "a" => "b"
+                )
+      stub_yaml!(
+                {
+                  "common" => { "yy" => 2 },
+                  "c" => "d",
+                },
+                  ".kitchen.local.yml"
+                )
 
       loader.read.must_equal(
-        :a => "b",
-        :c => "d",
-        :common => { :xx => 1, :yy => 2 }
+        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_yaml!("common" => { "xx" => 1 },
+                 "a" => "b"
+                )
+      stub_yaml!(
+                {
+                  "common" => { "yy" => 2 },
+                  "c" => "d",
+                },
+                  ".kitchen.local.yml"
+                )
       stub_global!(
         "common" => { "zz" => 3 },
         "e" => "f"
       )
 
       loader.read.must_equal(
-        :a => "b",
-        :c => "d",
-        :e => "f",
-        :common => { :xx => 1, :yy => 2, :zz => 3 }
+        a: "b",
+        c: "d",
+        e: "f",
+        common: { xx: 1, yy: 2, zz: 3 }
       )
     end
 
@@ -158,55 +159,48 @@ describe Kitchen::Loader::YAML do
       stub_global!(
         "common" => { "thekey" => "nope" }
       )
-      stub_yaml!(".kitchen.yml",
-        "common" => { "thekey" => "yep" }
-      )
+      stub_yaml!("common" => { "thekey" => "yep" })
 
-      loader.read.must_equal(: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!("common" => { "thekey" => "nope" })
+      stub_yaml!(
+                  { "common" => { "thekey" => "yep" } },
+                  ".kitchen.local.yml"
+                )
 
-      loader.read.must_equal(:common => { :thekey => "yep" })
+      loader.read.must_equal(common: { thekey: "yep" })
     end
 
     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_yaml!("common" => { "thekey" => "nope" })
+      stub_yaml!(
+                  { "common" => { "thekey" => "yep" } },
+                  ".kitchen.local.yml"
+                )
       stub_global!(
         "common" => { "thekey" => "kinda" }
       )
 
-      loader.read.must_equal(:common => { :thekey => "yep" })
+      loader.read.must_equal(common: { thekey: "yep" })
     end
 
     NORMALIZED_KEYS = {
       "driver" => "name",
       "provisioner" => "name",
-      "busser" => "version"
-    }
+      "busser" => "version",
+    }.freeze
 
     NORMALIZED_KEYS.each do |key, default_key|
-
       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"
-          )
+          stub_yaml!(key => { "dakey" => "ya" })
+          stub_yaml!(
+                      { key => "namey" },
+                      ".kitchen.local.yml"
+                    )
 
           loader.read.must_equal(
             key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
@@ -214,12 +208,11 @@ describe Kitchen::Loader::YAML do
         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" }
-          )
+          stub_yaml!(key => "namey")
+          stub_yaml!(
+                      { key => { "dakey" => "ya" } },
+                      ".kitchen.local.yml"
+                    )
 
           loader.read.must_equal(
             key.to_sym => { default_key.to_sym => "namey", :dakey => "ya" }
@@ -227,25 +220,23 @@ describe Kitchen::Loader::YAML do
         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",
-            key => nil
-          )
+          stub_yaml!(key => { "dakey" => "ya" })
+          stub_yaml!(
+                      { key => nil },
+                      ".kitchen.local.yml"
+                    )
 
           loader.read.must_equal(
-            key.to_sym => { :dakey => "ya" }
+            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",
-            key => nil
-          )
+          stub_yaml!(key => "namey")
+          stub_yaml!(
+                      { key => nil },
+                      ".kitchen.local.yml"
+                    )
 
           loader.read.must_equal(
             key.to_sym => { default_key.to_sym => "namey" }
@@ -253,9 +244,7 @@ describe Kitchen::Loader::YAML do
         end
 
         it "merges global with #{key} string value over yaml with hash value" do
-          stub_yaml!(".kitchen.yml",
-            key => { "dakey" => "ya" }
-          )
+          stub_yaml!(key => { "dakey" => "ya" })
           stub_global!(
             key => "namey"
           )
@@ -266,9 +255,7 @@ describe Kitchen::Loader::YAML do
         end
 
         it "merges global with #{key} hash value over yaml with string value" do
-          stub_yaml!(".kitchen.yml",
-            key => "namey"
-          )
+          stub_yaml!(key => "namey")
           stub_global!(
             key => { "dakey" => "ya" }
           )
@@ -279,38 +266,33 @@ describe Kitchen::Loader::YAML do
         end
 
         it "merges global with #{key} nil value over yaml with hash value" do
-          stub_yaml!(".kitchen.yml",
-            key => { "dakey" => "ya" }
-          )
+          stub_yaml!(key => { "dakey" => "ya" })
           stub_global!(
             key => nil
           )
 
           loader.read.must_equal(
-            key.to_sym => { :dakey => "ya" }
+            key.to_sym => { dakey: "ya" }
           )
         end
 
         it "merges global with #{key} hash value over yaml with nil value" do
-          stub_yaml!(".kitchen.yml",
-            key => nil
-          )
+          stub_yaml!(key => nil)
           stub_global!(
             key => { "dakey" => "ya" }
           )
 
           loader.read.must_equal(
-            key.to_sym => { :dakey => "ya" }
+            key.to_sym => { dakey: "ya" }
           )
         end
 
         it "merges global, local, over yaml with mixed hash, string, nil values" do
-          stub_yaml!(".kitchen.yml",
-            key => nil
-          )
-          stub_yaml!(".kitchen.local.yml",
-            key => "namey"
-          )
+          stub_yaml!(key => nil)
+          stub_yaml!(
+                      { key => "namey" },
+                      ".kitchen.local.yml"
+                    )
           stub_global!(
             key => { "dakey" => "ya" }
           )
@@ -323,30 +305,30 @@ describe Kitchen::Loader::YAML do
     end
 
     it "handles a kitchen.local.yml with no yaml elements" do
-      stub_yaml!(".kitchen.yml",
-        "a" => "b"
-      )
-      stub_yaml!(".kitchen.local.yml", Hash.new)
+      stub_yaml!("a" => "b")
+      stub_yaml!({}, ".kitchen.local.yml")
 
-      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!({})
+      stub_yaml!(
+        { "a" => "b" },
+        ".kitchen.local.yml"
       )
 
-      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!(nil)
+      stub_yaml!(
+        { "a" => "b" },
+        ".kitchen.local.yml"
       )
 
-      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
@@ -364,7 +346,7 @@ 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
@@ -375,11 +357,11 @@ describe Kitchen::Loader::YAML do
           wakka: boop
         YAML
       end
-      stub_yaml!(".kitchen.yml", Hash.new)
+      stub_yaml!({})
 
       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
@@ -388,7 +370,7 @@ describe Kitchen::Loader::YAML do
 
       err = proc { loader.read }.must_raise Kitchen::UserError
       err.message.must_match Regexp.new(
-        "Error parsing ([a-zA-Z]:)?\/tmp\/\.kitchen\.yml")
+        "Error parsing ([a-zA-Z]:)?/tmp/.kitchen.yml")
     end
 
     it "raises a UserError if kitchen.yml cannot be parsed" do
@@ -397,20 +379,20 @@ describe Kitchen::Loader::YAML do
 
       err = proc { loader.read }.must_raise Kitchen::UserError
       err.message.must_match Regexp.new(
-        "Error parsing ([a-zA-Z]:)?\/tmp\/\.kitchen\.yml")
+        "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)
+      loader.read.must_equal({})
     end
 
     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 "&*%^*" }
-      stub_yaml!(".kitchen.yml", Hash.new)
+      stub_yaml!({})
 
       proc { loader.read }.must_raise Kitchen::UserError
     end
@@ -424,7 +406,7 @@ describe Kitchen::Loader::YAML do
         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
@@ -438,7 +420,7 @@ describe Kitchen::Loader::YAML do
 
       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")
+        "Error parsing ERB content in ([a-zA-Z]:)?/tmp/.kitchen.yml")
     end
 
     it "evaluates kitchen.local.yml through erb before loading by default" do
@@ -451,18 +433,18 @@ describe Kitchen::Loader::YAML do
           <% end %>
         YAML
       end
-      stub_yaml!(".kitchen.yml", "spinach" => "salad")
+      stub_yaml!("spinach" => "salad")
 
       loader.read.must_equal(
-        :spinach => "salad",
-        :noodle => "soup",
-        :mushroom => "soup"
+        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}/, "")
@@ -471,12 +453,12 @@ describe Kitchen::Loader::YAML do
         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}/, "")
@@ -484,98 +466,94 @@ describe Kitchen::Loader::YAML do
           name: <%= "AHH".downcase %>
         YAML
       end
-      stub_yaml!(".kitchen.yml", Hash.new)
+      stub_yaml!({})
 
-      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!("a" => "b")
+      stub_yaml!(
+        { "superawesomesauceadditions" => "enabled, yo" },
+        ".kitchen.local.yml"
       )
 
-      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"
-      )
+        project_config: "/tmp/.kitchen.yml", process_global: false)
+      stub_yaml!("a" => "b")
       stub_global!(
         "superawesomesauceadditions" => "enabled, yo"
       )
 
-      loader.read.must_equal(:a => "b")
+      loader.read.must_equal(a: "b")
     end
   end
 
   describe "#diagnose" do
-
     it "returns a Hash" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
 
       loader.diagnose.must_be_kind_of(Hash)
     end
 
     it "contains erb processing information when true" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
 
       loader.diagnose[:process_erb].must_equal true
     end
 
     it "contains erb processing information when false" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
       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
 
     it "contains local processing information when true" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
 
       loader.diagnose[:process_local].must_equal true
     end
 
     it "contains local processing information when false" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
       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
 
     it "contains global processing information when true" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
 
       loader.diagnose[:process_global].must_equal true
     end
 
     it "contains global processing information when false" do
-      stub_yaml!(Hash.new)
+      stub_yaml!({})
       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
 
     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_yaml!("from_project" => "project",
+                   "common" => { "p" => "pretty" }
+                  )
+        stub_yaml!({
+            "from_local" => "local",
+            "common" => { "l" => "looky" },
+          },
+          ".kitchen.local.yml"
         )
         stub_global!(
           "from_global" => "global",
@@ -584,8 +562,8 @@ describe Kitchen::Loader::YAML do
       end
 
       it "global config contains a filename" do
-        loader.diagnose[:global_config][:filename].
-          must_equal File.join(ENV["HOME"].gsub('\\', "/"), ".kitchen/config.yml")
+        loader.diagnose[:global_config][:filename]
+          .must_equal File.join(ENV["HOME"].tr('\\', "/"), ".kitchen/config.yml")
       end
 
       it "global config contains raw data" do
@@ -596,8 +574,8 @@ describe Kitchen::Loader::YAML do
       end
 
       it "project config contains a filename" do
-        loader.diagnose[:project_config][:filename].
-          must_match %r{/tmp/.kitchen.yml$}
+        loader.diagnose[:project_config][:filename]
+          .must_match %r{/tmp/.kitchen.yml$}
       end
 
       it "project config contains raw data" do
@@ -608,8 +586,8 @@ describe Kitchen::Loader::YAML do
       end
 
       it "local config contains a filename" do
-        loader.diagnose[:local_config][:filename].
-          must_match %r{/tmp/.kitchen.local.yml$}
+        loader.diagnose[:local_config][:filename]
+          .must_match %r{/tmp/.kitchen.local.yml$}
       end
 
       it "local config contains raw data" do
@@ -620,8 +598,8 @@ describe Kitchen::Loader::YAML do
       end
 
       it "combined config contains a nil filename" do
-        loader.diagnose[:combined_config][:filename].
-          must_equal nil
+        loader.diagnose[:combined_config][:filename]
+          .must_equal nil
       end
 
       it "combined config contains raw data" do
@@ -632,13 +610,12 @@ describe Kitchen::Loader::YAML do
           "common" => {
             "g" => "goody",
             "p" => "pretty",
-            "l" => "looky"
+            "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|
@@ -647,28 +624,27 @@ describe Kitchen::Loader::YAML do
         end
 
         it "uses an error hash with the raw file contents" do
-          loader.diagnose[:global_config][:raw_data][:error][:raw_file].
-            must_equal "&*%^*"
+          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}
+          loader.diagnose[:global_config][:raw_data][:error][:exception]
+            .must_match /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}
+          loader.diagnose[:global_config][:raw_data][:error][:message]
+            .must_match /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
+          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 "&*%^*"
@@ -676,28 +652,27 @@ describe Kitchen::Loader::YAML do
         end
 
         it "uses an error hash with the raw file contents" do
-          loader.diagnose[:project_config][:raw_data][:error][:raw_file].
-            must_equal "&*%^*"
+          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}
+          loader.diagnose[:project_config][:raw_data][:error][:exception]
+            .must_match /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}
+          loader.diagnose[:project_config][:raw_data][:error][:message]
+            .must_match /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
+          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 "&*%^*"
@@ -705,28 +680,27 @@ describe Kitchen::Loader::YAML do
         end
 
         it "uses an error hash with the raw file contents" do
-          loader.diagnose[:local_config][:raw_data][:error][:raw_file].
-            must_equal "&*%^*"
+          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}
+          loader.diagnose[:local_config][:raw_data][:error][:exception]
+            .must_match /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}
+          loader.diagnose[:local_config][:raw_data][:error][:message]
+            .must_match /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
+          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 "&*%^*"
@@ -734,23 +708,23 @@ describe Kitchen::Loader::YAML do
         end
 
         it "uses an error hash with nil raw file contents" do
-          loader.diagnose[:combined_config][:raw_data][:error][:raw_file].
-            must_equal nil
+          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}
+          loader.diagnose[:combined_config][:raw_data][:error][:exception]
+            .must_match /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}
+          loader.diagnose[:combined_config][:raw_data][:error][:message]
+            .must_match /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
+          loader.diagnose[:combined_config][:raw_data][:error][:backtrace]
+            .must_be_kind_of Array
         end
       end
     end
@@ -763,12 +737,12 @@ describe Kitchen::Loader::YAML do
     File.open(path, "wb") { |f| f.write(hash.to_yaml) }
   end
 
-  def stub_yaml!(name = ".kitchen.yml", hash)
+  def stub_yaml!(hash, name = ".kitchen.yml")
     stub_file(File.join("/tmp", name), hash)
   end
 
   def stub_global!(hash)
     stub_file(File.join(File.expand_path(ENV["HOME"]),
-      ".kitchen", "config.yml"), hash)
+                        ".kitchen", "config.yml"), hash)
   end
 end