test-kitchen 1.23.3 → 1.23.4

data/spec/kitchen/lazy_hash_spec.rb

@@ -1,113 +0,0 @@
-# -*- 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_relative "../spec_helper"
-
-require "kitchen/lazy_hash"
-
-describe Kitchen::LazyHash do
-  let(:context) do
-    stub(color: "blue", metal: "heavy")
-  end
-
-  let(:hash_obj) do
-    {
-      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
-
-    it "invokes call on values that are lambdas" do
-      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_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_obj, context).to_hash
-
-      converted.must_be_instance_of Hash
-      converted.fetch(:shed_color).must_equal "blue"
-      converted.fetch(:barn).must_equal "locked"
-      converted.fetch(:genre).must_equal "heavy metal"
-    end
-  end
-
-  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"
-    end
-  end
-
-  describe "enumerable" do
-    it "is an Enumerable" do
-      assert Kitchen::LazyHash.new(hash_obj, context).is_a? Enumerable
-    end
-
-    it "returns an Enumerator from each() if no block given" do
-      e = Kitchen::LazyHash.new(hash_obj, context).each
-      e.is_a? Enumerator
-      e.next.must_equal [:shed_color, "blue"]
-      e.next.must_equal [:barn, "locked"]
-      e.next.must_equal [:genre, "heavy metal"]
-    end
-
-    it "yields each item to the block if a block is given to each()" do
-      items = []
-      Kitchen::LazyHash.new(hash_obj, context).each { |i| items << i }
-      items.must_equal [[:shed_color, "blue"], [:barn, "locked"], [:genre, "heavy metal"]]
-    end
-  end
-end

data/spec/kitchen/lifecycle_hooks_spec.rb

@@ -1,171 +0,0 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Noah Kantrowitz <noah@coderanger.net>
-#
-# Copyright (C) 2018, Noah Kantrowitz
-#
-# 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_relative "../spec_helper"
-
-require "kitchen/errors"
-require "kitchen/lifecycle_hooks"
-
-describe Kitchen::LifecycleHooks do
-  let(:suite) { mock("suite").tap { |i| i.stubs(name: "default") } }
-  let(:platform) { mock("platform").tap { |i| i.stubs(name: "toaster-1.0") } }
-  let(:state_file) { mock("state_file").tap { |s| s.stubs(read: { hostname: "localhost" }) } }
-  let(:connection) { mock("connection") }
-  let(:transport) { mock("transport").tap { |t| t.stubs(:connection).with({ hostname: "localhost" }).returns(connection) } }
-  let(:last_action) { :create }
-  let(:instance) { mock("instance").tap { |i| i.stubs(name: "default-toaster-10", transport: transport, last_action: last_action, suite: suite, platform: platform) } }
-  let(:config) { { kitchen_root: "/kitchen" } }
-  let(:lifecycle_hooks) { Kitchen::LifecycleHooks.new(config).tap { |lh| lh.finalize_config!(instance) } }
-
-  def run_lifecycle_hooks
-    lifecycle_hooks.run_with_hooks(:create, state_file) {}
-  end
-
-  # Pull this out because it's used in a bunch of tests.
-  STANDARD_LOCAL_OPTIONS = {
-    cwd: "/kitchen",
-    environment: {
-      "KITCHEN_INSTANCE_NAME" => "default-toaster-10",
-      "KITCHEN_SUITE_NAME" => "default",
-      "KITCHEN_PLATFORM_NAME" => "toaster-1.0",
-      "KITCHEN_INSTANCE_HOSTNAME" => "localhost",
-    },
-  }.freeze
-
-  it "runs a single local command" do
-    config.update(post_create: ["echo foo"])
-    lifecycle_hooks.expects(:run_command).with("echo foo", STANDARD_LOCAL_OPTIONS)
-    run_lifecycle_hooks
-  end
-
-  it "runs multiple local commands" do
-    config.update(post_create: ["echo foo", { local: "echo bar" }])
-    lifecycle_hooks.expects(:run_command).with("echo foo", STANDARD_LOCAL_OPTIONS)
-    lifecycle_hooks.expects(:run_command).with("echo bar", STANDARD_LOCAL_OPTIONS)
-    run_lifecycle_hooks
-  end
-
-  it "runs multiple local hooks" do
-    config.update(pre_create: ["echo foo"], post_create: ["echo bar"])
-    lifecycle_hooks.expects(:run_command).with("echo foo", STANDARD_LOCAL_OPTIONS)
-    lifecycle_hooks.expects(:run_command).with("echo bar", STANDARD_LOCAL_OPTIONS)
-    run_lifecycle_hooks
-  end
-
-  it "runs a local command with a user option" do
-    config.update(post_create: [{ local: "echo foo", user: "bar" }])
-    lifecycle_hooks.expects(:run_command).with("echo foo", {
-      cwd: "/kitchen",
-      user: "bar",
-      environment: {
-        "KITCHEN_INSTANCE_NAME" => "default-toaster-10",
-        "KITCHEN_SUITE_NAME" => "default",
-        "KITCHEN_PLATFORM_NAME" => "toaster-1.0",
-        "KITCHEN_INSTANCE_HOSTNAME" => "localhost",
-      },
-    })
-    run_lifecycle_hooks
-  end
-
-  it "runs a local command with environment options" do
-    config.update(post_create: [{ local: "echo foo", environment: { FOO: "one", BAR: "two" } }])
-    lifecycle_hooks.expects(:run_command).with("echo foo", {
-      cwd: "/kitchen",
-      environment: {
-        "FOO" => "one",
-        "BAR" => "two",
-        "KITCHEN_INSTANCE_NAME" => "default-toaster-10",
-        "KITCHEN_SUITE_NAME" => "default",
-        "KITCHEN_PLATFORM_NAME" => "toaster-1.0",
-        "KITCHEN_INSTANCE_HOSTNAME" => "localhost",
-      },
-    })
-    run_lifecycle_hooks
-  end
-
-  it "runs a local command with a relative cwd option" do
-    config.update(post_create: [{ local: "echo foo", cwd: "test" }])
-    lifecycle_hooks.expects(:run_command).with("echo foo", {
-      cwd: os_safe_root_path("/kitchen/test"),
-      environment: {
-        "KITCHEN_INSTANCE_NAME" => "default-toaster-10",
-        "KITCHEN_SUITE_NAME" => "default",
-        "KITCHEN_PLATFORM_NAME" => "toaster-1.0",
-        "KITCHEN_INSTANCE_HOSTNAME" => "localhost",
-      },
-    })
-    run_lifecycle_hooks
-  end
-
-  it "runs a local command with an absolute cwd option" do
-    config.update(post_create: [{ local: "echo foo", cwd: "/test" }])
-    lifecycle_hooks.expects(:run_command).with("echo foo", {
-      cwd: os_safe_root_path("/test"),
-      environment: {
-        "KITCHEN_INSTANCE_NAME" => "default-toaster-10",
-        "KITCHEN_SUITE_NAME" => "default",
-        "KITCHEN_PLATFORM_NAME" => "toaster-1.0",
-        "KITCHEN_INSTANCE_HOSTNAME" => "localhost",
-      },
-    })
-    run_lifecycle_hooks
-  end
-
-  it "runs a single remote command" do
-    config.update(post_create: [{ remote: "echo foo" }])
-    lifecycle_hooks.expects(:run_command).never
-    connection.expects(:execute).with("echo foo")
-    run_lifecycle_hooks
-  end
-
-  it "rejects unknown hook targets" do
-    config.update(post_create: [{ banana: "echo foo" }])
-    lifecycle_hooks.expects(:run_command).never
-    proc { run_lifecycle_hooks }.must_raise Kitchen::UserError
-  end
-
-  it "runs mixed local and remote commands" do
-    config.update(post_create: ["echo foo", { local: "echo bar" }, { remote: "echo baz" }])
-    lifecycle_hooks.expects(:run_command).with("echo foo", STANDARD_LOCAL_OPTIONS)
-    lifecycle_hooks.expects(:run_command).with("echo bar", STANDARD_LOCAL_OPTIONS)
-    connection.expects(:execute).with("echo baz")
-    run_lifecycle_hooks
-  end
-
-  describe "with no last_action" do
-    let(:last_action) { nil }
-
-    it "runs local commands" do
-      config.update(post_create: [{ local: "echo foo" }])
-      lifecycle_hooks.expects(:run_command).with("echo foo", STANDARD_LOCAL_OPTIONS)
-      run_lifecycle_hooks
-    end
-
-    it "fails on remote commands" do
-      config.update(post_create: [{ remote: "echo foo" }])
-      lifecycle_hooks.expects(:run_command).never
-      proc { run_lifecycle_hooks }.must_raise Kitchen::UserError
-    end
-
-    it "ignores skippable remote commands" do
-      config.update(post_create: [{ remote: "echo foo", skippable: true }])
-      lifecycle_hooks.expects(:run_command).never
-      run_lifecycle_hooks
-    end
-  end
-end

data/spec/kitchen/loader/yaml_spec.rb

@@ -1,787 +0,0 @@
-# -*- 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_relative "../../spec_helper"
-
-require "kitchen/errors"
-require "kitchen/util"
-require "kitchen/loader/yaml"
-
-class Yamled
-  attr_accessor :foo
-end
-
-describe Kitchen::Loader::YAML do
-  let(:loader) do
-    Kitchen::Loader::YAML.new(project_config: "/tmp/.kitchen.yml")
-  end
-
-  before do
-    FakeFS.activate!
-    FileUtils.mkdir_p("/tmp")
-  end
-
-  after do
-    FakeFS.deactivate!
-    FakeFS::FileSystem.clear
-  end
-
-  describe ".initialize" do
-    it "sets project_config based on Dir.pwd by default" do
-      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"))
-    end
-
-    it "when kitchen.yml not present, falls back to .kitchen.yml" do
-      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"))
-    end
-
-    it "prefers kitchen.yml to .kitchen.yml" do
-      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"))
-    end
-
-    it "errors when kitchen.yml and .kitchen.yml are both present" do
-      stub_file(File.join(Dir.pwd, "kitchen.yml"), {})
-      stub_file(File.join(Dir.pwd, ".kitchen.yml"), {})
-      proc { Kitchen::Loader::YAML.new }.must_raise Kitchen::UserError
-    end
-
-    it "sets project_config from parameter, if given" do
-      stub_file("/tmp/crazyfunkytown.file", {})
-      loader = Kitchen::Loader::YAML.new(
-        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"), {})
-      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", {})
-      loader = Kitchen::Loader::YAML.new(
-        project_config: "/tmp/.kitchen.yml")
-
-      loader.diagnose[:local_config][:filename]
-        .must_match %r{/tmp/.kitchen.local.yml$}
-    end
-
-    it "errors if both visible and hidden copies of default local_config exist" do
-      stub_file("/tmp/kitchen.local.yml", {})
-      stub_file("/tmp/.kitchen.local.yml", {})
-      proc { Kitchen::Loader::YAML.new(project_config: "/tmp/.kitchen.yml") }
-        .must_raise Kitchen::UserError
-    end
-
-    it "sets local_config from parameter, if given" do
-      stub_file("/tmp/crazyfunkytown.file", {})
-      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"), {})
-      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", {})
-      loader = Kitchen::Loader::YAML.new(
-        global_config: "/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")
-    end
-
-    it "deep merges in kitchen.local.yml configuration with kitchen.yml" do
-      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 }
-      )
-    end
-
-    it "deep merges in a global config file with all other configs" do
-      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 }
-      )
-    end
-
-    it "merges kitchen.yml over configuration in global config" do
-      stub_global!(
-        "common" => { "thekey" => "nope" }
-      )
-      stub_yaml!("common" => { "thekey" => "yep" })
-
-      loader.read.must_equal(common: { thekey: "yep" })
-    end
-
-    it "merges kitchen.local.yml over configuration in kitchen.yml" do
-      stub_yaml!("common" => { "thekey" => "nope" })
-      stub_yaml!(
-                  { "common" => { "thekey" => "yep" } },
-                  ".kitchen.local.yml"
-                )
-
-      loader.read.must_equal(common: { thekey: "yep" })
-    end
-
-    it "merges kitchen.local.yml over both kitchen.yml and global config" do
-      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" })
-    end
-
-    NORMALIZED_KEYS = {
-      "driver" => "name",
-      "provisioner" => "name",
-      "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!(key => { "dakey" => "ya" })
-          stub_yaml!(
-                      { key => "namey" },
-                      ".kitchen.local.yml"
-                    )
-
-          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!(key => "namey")
-          stub_yaml!(
-                      { key => { "dakey" => "ya" } },
-                      ".kitchen.local.yml"
-                    )
-
-          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!(key => { "dakey" => "ya" })
-          stub_yaml!(
-                      { key => nil },
-                      ".kitchen.local.yml"
-                    )
-
-          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!(key => "namey")
-          stub_yaml!(
-                      { key => nil },
-                      ".kitchen.local.yml"
-                    )
-
-          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!(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!(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!(key => { "dakey" => "ya" })
-          stub_global!(
-            key => nil
-          )
-
-          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!(key => nil)
-          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!(key => nil)
-          stub_yaml!(
-                      { key => "namey" },
-                      ".kitchen.local.yml"
-                    )
-          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!("a" => "b")
-      stub_yaml!({}, ".kitchen.local.yml")
-
-      loader.read.must_equal(a: "b")
-    end
-
-    it "handles a kitchen.yml with no yaml elements" do
-      stub_yaml!({})
-      stub_yaml!(
-        { "a" => "b" },
-        ".kitchen.local.yml"
-      )
-
-      loader.read.must_equal(a: "b")
-    end
-
-    it "handles a kitchen.yml with yaml elements that parse as nil" do
-      stub_yaml!(nil)
-      stub_yaml!(
-        { "a" => "b" },
-        ".kitchen.local.yml"
-      )
-
-      loader.read.must_equal(a: "b")
-    end
-
-    it "raises an UserError if the config_file does not exist" do
-      proc { loader.read }.must_raise Kitchen::UserError
-    end
-
-    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}/, "")
-          --- !ruby/object:Yamled
-          foo: bar
-        YAML
-      end
-
-      proc { loader.read }.must_raise Kitchen::UserError
-    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}/, "")
-          --- !ruby/object:Yamled
-          wakka: boop
-        YAML
-      end
-      stub_yaml!({})
-
-      proc { loader.read }.must_raise Kitchen::UserError
-    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 "&*%^*" }
-
-      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" }
-
-      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({})
-    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!({})
-
-      proc { loader.read }.must_raise Kitchen::UserError
-    end
-
-    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}/, "")
-          ---
-          name: <%= "AHH".downcase + "choo" %>
-        YAML
-      end
-
-      loader.read.must_equal(name: "ahhchoo")
-    end
-
-    it "accepts kitchen.yml with alias" do
-      FileUtils.mkdir_p "/tmp"
-      File.open("/tmp/.kitchen.yml", "wb") do |f|
-        f.write <<-'YAML'.gsub(/^ {10}/, "")
-          ---
-          xxx: &k
-            foo: bar
-          yyy: *k
-        YAML
-      end
-
-      loader.read[:yyy].must_equal(foo: "bar")
-    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|
-        f.write <<-'YAML'.gsub(/^ {10}/, "")
-          ---
-          <% %w{noodle mushroom}.each do |kind| %>
-            <%= kind %>: soup
-          <% end %>
-        YAML
-      end
-      stub_yaml!("spinach" => "salad")
-
-      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)
-      FileUtils.mkdir_p "/tmp"
-      File.open("/tmp/.kitchen.yml", "wb") do |f|
-        f.write <<-'YAML'.gsub(/^ {10}/, "")
-          ---
-          name: <%= "AHH".downcase %>
-        YAML
-      end
-
-      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)
-      FileUtils.mkdir_p "/tmp"
-      File.open("/tmp/.kitchen.local.yml", "wb") do |f|
-        f.write <<-'YAML'.gsub(/^ {10}/, "")
-          ---
-          name: <%= "AHH".downcase %>
-        YAML
-      end
-      stub_yaml!({})
-
-      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!("a" => "b")
-      stub_yaml!(
-        { "superawesomesauceadditions" => "enabled, yo" },
-        ".kitchen.local.yml"
-      )
-
-      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!("a" => "b")
-      stub_global!(
-        "superawesomesauceadditions" => "enabled, yo"
-      )
-
-      loader.read.must_equal(a: "b")
-    end
-  end
-
-  describe "#diagnose" do
-    it "returns a Hash" do
-      stub_yaml!({})
-
-      loader.diagnose.must_be_kind_of(Hash)
-    end
-
-    it "contains erb processing information when true" do
-      stub_yaml!({})
-
-      loader.diagnose[:process_erb].must_equal true
-    end
-
-    it "contains erb processing information when false" do
-      stub_yaml!({})
-      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!({})
-
-      loader.diagnose[:process_local].must_equal true
-    end
-
-    it "contains local processing information when false" do
-      stub_yaml!({})
-      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!({})
-
-      loader.diagnose[:process_global].must_equal true
-    end
-
-    it "contains global processing information when false" do
-      stub_yaml!({})
-      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!("from_project" => "project",
-                   "common" => { "p" => "pretty" }
-                  )
-        stub_yaml!({
-            "from_local" => "local",
-            "common" => { "l" => "looky" },
-          },
-          ".kitchen.local.yml"
-        )
-        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"].tr('\\', "/"), ".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_be_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(/Kitchen::UserError/)
-        end
-
-        it "uses an error hash with the exception message" do
-          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
-        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(/Kitchen::UserError/)
-        end
-
-        it "uses an error hash with the exception message" do
-          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
-        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(/Kitchen::UserError/)
-        end
-
-        it "uses an error hash with the exception message" do
-          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
-        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_be_nil
-        end
-
-        it "uses an error hash with the exception" do
-          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(/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)
-    FileUtils.mkdir_p(File.dirname(path))
-    File.open(path, "wb") { |f| f.write(hash.to_yaml) }
-  end
-
-  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)
-  end
-end