test-kitchen 1.2.1 → 1.3.0

data/spec/kitchen/collection_spec.rb

@@ -16,16 +16,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative '../spec_helper'
-require 'ostruct'
+require_relative "../spec_helper"
+require "ostruct"
 
-require 'kitchen/collection'
+require "kitchen/collection"
 
 describe Kitchen::Collection do
 
   let(:collection) do
     Kitchen::Collection.new([
-      obj('one'), obj('two', 'a'), obj('two', 'b'), obj('three')
+      obj("one"), obj("two", "a"), obj("two", "b"), obj("three")
     ])
   end
 
@@ -36,15 +36,15 @@ describe Kitchen::Collection do
   describe "#get" do
 
     it "returns a single object by its name" do
-      collection.get('three').must_equal obj('three')
+      collection.get("three").must_equal obj("three")
     end
 
     it "returns the first occurance of an object by its name" do
-      collection.get('two').must_equal obj('two', 'a')
+      collection.get("two").must_equal obj("two", "a")
     end
 
     it "returns nil if an object cannot be found by its name" do
-      collection.get('nope').must_be_nil
+      collection.get("nope").must_be_nil
     end
   end
 
@@ -53,8 +53,8 @@ describe Kitchen::Collection do
     it "returns a Collection of objects whose name matches the regex" do
       result = collection.get_all(/(one|three)/)
       result.size.must_equal 2
-      result[0].must_equal obj('one')
-      result[1].must_equal obj('three')
+      result[0].must_equal obj("one")
+      result[1].must_equal obj("three")
       result.get_all(/one/).size.must_equal 1
     end
 
@@ -68,7 +68,7 @@ describe Kitchen::Collection do
   describe "#as_name" do
 
     it "returns an Array of names as strings" do
-      collection.as_names.must_equal %w{one two two three}
+      collection.as_names.must_equal %w[one two two three]
     end
   end
 

data/spec/kitchen/color_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/color'
+require "kitchen/color"
 
 describe Kitchen::Color do
 

data/spec/kitchen/config_spec.rb

@@ -16,30 +16,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative '../spec_helper'
-
-require 'kitchen'
-require 'kitchen/logging'
-require 'kitchen/collection'
-require 'kitchen/config'
-require 'kitchen/driver'
-require 'kitchen/instance'
-require 'kitchen/platform'
-require 'kitchen/provisioner'
-require 'kitchen/suite'
-require 'kitchen/util'
+require_relative "../spec_helper"
+
+require "kitchen"
+require "kitchen/logging"
+require "kitchen/collection"
+require "kitchen/config"
+require "kitchen/driver"
+require "kitchen/instance"
+require "kitchen/platform"
+require "kitchen/provisioner"
+require "kitchen/suite"
+require "kitchen/util"
 
 module Kitchen
 
   class DummyLoader
 
+    attr_writer :data
+
     def read
       @data || Hash.new
     end
-
-    def data=(hash)
-      @data = hash
-    end
   end
 end
 
@@ -49,9 +47,25 @@ describe Kitchen::Config do
   let(:config)  { Kitchen::Config.new(opts) }
 
   let(:opts) do
-    { :loader => loader, :kitchen_root => "/tmp/that/place",
-      :log_root => "/tmp/logs", :test_base_path => "/testing/yo",
-      :log_level => :debug }
+    {
+      :loader         => loader,
+      :kitchen_root   => "/tmp/that/place",
+      :log_root       => "/tmp/logs",
+      :test_base_path => "/testing/yo",
+      :log_level      => :debug
+    }
+  end
+
+  let(:default_kitchen_config) do
+    {
+      :defaults => {
+        :driver => "dummy",
+        :provisioner => "chef_solo"
+      },
+      :kitchen_root => "/tmp/that/place",
+      :test_base_path => "/testing/yo",
+      :log_level => :debug
+    }
   end
 
   describe "#loader" do
@@ -121,75 +135,233 @@ describe Kitchen::Config do
 
   describe "#platforms" do
 
-    it "returns an array of platforms" do
-      stub_data!({
-        :platforms => [
-          { :name => 'one' },
-          { :name => 'two' }
-        ]
-      })
+    before do
+      Kitchen::DataMunger.stubs(:new).returns(munger)
+      Kitchen::Platform.stubs(:new).returns("platform")
+    end
+
+    let(:munger) do
+      stub(
+        :platform_data => [{ :one => "a" }, { :two => "b" }]
+      )
+    end
+
+    it "loader loads data" do
+      loader.expects(:read).returns(Hash.new)
+
+      config.platforms
+    end
+
+    it "constucts a munger with loader data and defaults" do
+      loader.stubs(:read).returns("datum")
+
+      Kitchen::DataMunger.expects(:new).with("datum", default_kitchen_config).
+        returns(munger)
+
+      config.platforms
+    end
+
+    it "platform_data is called on munger" do
+      munger.expects(:platform_data).returns([])
+
+      config.platforms
+    end
+
+    it "contructs Platform objects" do
+      Kitchen::Platform.expects(:new).with(:one => "a")
+      Kitchen::Platform.expects(:new).with(:two => "b")
 
-      config.platforms.size.must_equal 2
-      config.platforms[0].name.must_equal 'one'
-      config.platforms[1].name.must_equal 'two'
+      config.platforms
     end
 
-    it "returns an empty Array if no platforms are given" do
-      stub_data!({})
+    it "returns a Collection of platforms" do
+      Kitchen::Platform.stubs(:new).
+        with(:one => "a").returns(stub(:name => "one"))
+      Kitchen::Platform.stubs(:new).
+        with(:two => "b").returns(stub(:name => "two"))
 
-      config.platforms.must_equal []
+      config.platforms.as_names.must_equal %w[one two]
     end
   end
 
   describe "#suites" do
 
-    it "returns an array of suites" do
-      stub_data!({
-        :suites => [
-          { :name => 'one' },
-          { :name => 'two' }
-        ]
-      })
+    before do
+      Kitchen::DataMunger.stubs(:new).returns(munger)
+      Kitchen::Suite.stubs(:new).returns("suite")
+    end
+
+    let(:munger) do
+      stub(
+        :suite_data => [{ :one => "a" }, { :two => "b" }]
+      )
+    end
+
+    it "loader loads data" do
+      loader.expects(:read).returns(Hash.new)
+
+      config.suites
+    end
+
+    it "constucts a munger with loader data and defaults" do
+      loader.stubs(:read).returns("datum")
+
+      Kitchen::DataMunger.expects(:new).with("datum", default_kitchen_config).
+        returns(munger)
+
+      config.suites
+    end
+
+    it "platform_data is called on munger" do
+      munger.expects(:suite_data).returns([])
 
-      config.suites.size.must_equal 2
-      config.suites[0].name.must_equal 'one'
-      config.suites[1].name.must_equal 'two'
+      config.suites
     end
 
-    it "returns an empty Array if no suites are given" do
-      stub_data!({})
+    it "contructs Suite objects" do
+      Kitchen::Suite.expects(:new).with(:one => "a")
+      Kitchen::Suite.expects(:new).with(:two => "b")
 
-      config.suites.must_equal []
+      config.suites
+    end
+
+    it "returns a Collection of suites" do
+      Kitchen::Suite.stubs(:new).
+        with(:one => "a").returns(stub(:name => "one"))
+      Kitchen::Suite.stubs(:new).
+        with(:two => "b").returns(stub(:name => "two"))
+
+      config.suites.as_names.must_equal %w[one two]
     end
   end
 
   describe "#instances" do
 
-    it "returns an empty Array if no suites and platforms are given" do
-      stub_data!({})
+    let(:platforms) do
+      [stub(:name => "unax")]
+    end
+
+    let(:suites) do
+      [stub(:name => "tiny", :includes => [], :excludes => [])]
+    end
+
+    let(:munger) do
+      stub(
+        :busser_data_for => { "junk" => true },
+        :driver_data_for => { "junk" => true },
+        :provisioner_data_for => { "junk" => true }
+      )
+    end
+
+    before do
+      Kitchen::Instance.stubs(:new).returns("instance")
+      Kitchen::Busser.stubs(:new).returns("busser")
+      Kitchen::Driver.stubs(:for_plugin).returns("driver")
+      Kitchen::Provisioner.stubs(:for_plugin).returns("provisioner")
+      Kitchen::Logger.stubs(:new).returns("logger")
+      Kitchen::StateFile.stubs(:new).returns("state_file")
+
+      Kitchen::DataMunger.stubs(:new).returns(munger)
+      config.stubs(:platforms).returns(platforms)
+      config.stubs(:suites).returns(suites)
+    end
+
+    it "constructs a Busser object" do
+      munger.expects(:busser_data_for).with("tiny", "unax").returns("datum")
+      Kitchen::Busser.unstub(:new)
+      Kitchen::Busser.expects(:new).with("tiny", "datum")
+
+      config.instances
+    end
+
+    it "constructs a Driver object" do
+      munger.expects(:driver_data_for).with("tiny", "unax").
+        returns(:name => "drivey", :datum => "lots")
+      Kitchen::Driver.unstub(:for_plugin)
+      Kitchen::Driver.expects(:for_plugin).
+        with("drivey", :name => "drivey", :datum => "lots")
 
-      config.instances.must_equal []
+      config.instances
+    end
+
+    it "constructs a Provisioner object" do
+      munger.expects(:provisioner_data_for).with("tiny", "unax").
+        returns(:name => "provey", :datum => "lots")
+      Kitchen::Provisioner.unstub(:for_plugin)
+      Kitchen::Provisioner.expects(:for_plugin).
+        with("provey", :name => "provey", :datum => "lots")
+
+      config.instances
     end
 
-    it "returns an array of instances" do
-      skip "much more needed here"
+    it "constructs a Logger object" do
+      Kitchen::Logger.unstub(:new)
+      Kitchen::Logger.expects(:new).with(
+        :stdout => STDOUT,
+        :color => :cyan,
+        :logdev => "/tmp/logs/tiny-unax.log",
+        :level => 0,
+        :progname => "tiny-unax"
+      )
+
+      config.instances
+    end
 
-      stub_data!({
-        :platforms => [
-          { :name => "p1" },
-          { :name => "p2" }
-        ],
-        :suites => [
-          { :name => 's1' },
-          { :name => 's2' }
-        ]
-      })
+    it "constructs a StateFile object" do
+      Kitchen::StateFile.unstub(:new)
+      Kitchen::StateFile.expects(:new).with("/tmp/that/place", "tiny-unax")
 
       config.instances
     end
+
+    it "constructs an Instance object from all built objects" do
+      Kitchen::Instance.unstub(:new)
+      Kitchen::Instance.expects(:new).with(
+        :busser => "busser",
+        :driver => "driver",
+        :logger => "logger",
+        :suite => suites.first,
+        :platform => platforms.first,
+        :provisioner => "provisioner",
+        :state_file => "state_file"
+      )
+      config.instances
+    end
   end
 
-  def stub_data!(hash)
-    loader.data = hash
+  describe "using Suite#includes" do
+
+    it "selects only platforms in a suite's includes array" do
+      config.stubs(:platforms).returns([
+        stub(:name => "good"),
+        stub(:name => "nope"),
+        stub(:name => "one")
+      ])
+      config.stubs(:suites).returns([
+        stub(:name => "selecta", :includes => %w[good one], :excludes => []),
+        stub(:name => "allem", :includes => [], :excludes => [])
+      ])
+
+      config.instances.as_names.must_equal [
+        "selecta-good", "selecta-one", "allem-good", "allem-nope", "allem-one"]
+    end
+  end
+
+  describe "using Suite#excludes" do
+
+    it "selects only platforms in a suite's includes array" do
+      config.stubs(:platforms).returns([
+        stub(:name => "good"),
+        stub(:name => "nope"),
+        stub(:name => "one")
+      ])
+      config.stubs(:suites).returns([
+        stub(:name => "selecta", :includes => [], :excludes => ["nope"]),
+        stub(:name => "allem", :includes => [], :excludes => [])
+      ])
+
+      config.instances.as_names.must_equal [
+        "selecta-good", "selecta-one", "allem-good", "allem-nope", "allem-one"]
+    end
   end
 end

data/spec/kitchen/configurable_spec.rb

@@ -0,0 +1,490 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2014, 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 "stringio"
+
+require "kitchen/errors"
+require "kitchen/configurable"
+
+module Kitchen
+
+  module Thing
+
+    class Tiny
+
+      include Kitchen::Configurable
+
+      def initialize(config = {})
+        init_config(config)
+      end
+    end
+
+    class StaticDefaults
+
+      include Kitchen::Configurable
+
+      default_config :beans, "kidney"
+      default_config :tunables, "flimflam" => "positate"
+      default_config :edible, true
+      default_config :fetch_command, "curl"
+      default_config :success_path, "./success"
+      default_config :beans_url do |subject|
+        "http://gim.me/#{subject[:beans]}"
+      end
+      default_config :command do |subject|
+        "#{subject[:fetch_command]} #{subject[:beans_url]}"
+      end
+      default_config :fetch_url do |subject|
+        "http://gim.me/beans-for/#{subject.instance.name}"
+      end
+
+      required_config :need_it
+      required_config :a_default
+      required_config :no_nuts do |attr, value, _subject|
+        raise UserError, "NO NUTS FOR #{attr}!" if value == "nuts"
+      end
+
+      expand_path_for :success_path
+      expand_path_for :relative_path, false
+      expand_path_for :another_path
+      expand_path_for :complex_path do |subject|
+        subject[:something_else] == "is_set"
+      end
+
+      def initialize(config = {})
+        init_config(config)
+      end
+    end
+
+    class SubclassDefaults < StaticDefaults
+
+      default_config :yea, "ya"
+      default_config :fetch_command, "wget"
+      default_config :fetch_url, "http://no.beans"
+
+      required_config :a_default do |_attr, value, _subject|
+        raise UserError, "Overriding a_default is fun" unless value == "please"
+      end
+
+      expand_path_for :another_path, false
+    end
+  end
+end
+
+describe Kitchen::Configurable do
+
+  let(:config)    { Hash.new }
+  let(:instance)  { stub(:name => "coolbeans", :to_str => "<instance>") }
+
+  let(:subject) do
+    Kitchen::Thing::Tiny.new(config).finalize_config!(instance)
+  end
+
+  describe "creation and setup" do
+
+    it "#instance returns its instance" do
+      subject.instance.must_equal instance
+    end
+
+    it "#finalize_config! raises ClientError if instance is nil" do
+      proc { Kitchen::Thing::Tiny.new({}).finalize_config!(nil) }.
+        must_raise(Kitchen::ClientError)
+    end
+
+    it "#finalize_config! returns self for chaining" do
+      t = Kitchen::Thing::Tiny.new({})
+      t.finalize_config!(instance).must_equal t
+    end
+  end
+
+  describe "configuration" do
+
+    describe "provided from the outside" do
+
+      it "returns provided config" do
+        config[:fruit] = %w[apples oranges]
+        config[:cool_enough] = true
+
+        subject[:fruit].must_equal %w[apples oranges]
+        subject[:cool_enough].must_equal true
+      end
+    end
+
+    describe "using static default_config statements" do
+
+      let(:config) do
+        { :need_it => true, :a_default => true }
+      end
+
+      let(:subject) do
+        Kitchen::Thing::StaticDefaults.new(config).finalize_config!(instance)
+      end
+
+      it "uses defaults" do
+        subject[:beans].must_equal "kidney"
+        subject[:tunables]["flimflam"].must_equal "positate"
+        subject[:edible].must_equal true
+      end
+
+      it "uses provided config over default_config" do
+        config[:beans] = "pinto"
+        config[:edible] = false
+
+        subject[:beans].must_equal "pinto"
+        subject[:edible].must_equal false
+      end
+
+      it "uses other config values to compute values" do
+        subject[:beans_url].must_equal "http://gim.me/kidney"
+        subject[:command].must_equal "curl http://gim.me/kidney"
+      end
+
+      it "computed value blocks have access to instance object" do
+        subject[:fetch_url].must_equal "http://gim.me/beans-for/coolbeans"
+      end
+
+      it "uses provided config over default_config for computed values" do
+        config[:command] = "echo listentome"
+        config[:beans] = "pinto"
+
+        subject[:command].must_equal "echo listentome"
+        subject[:beans_url].must_equal "http://gim.me/pinto"
+      end
+    end
+
+    describe "using inherited static default_config statements" do
+
+      let(:config) do
+        { :need_it => true, :a_default => "please" }
+      end
+
+      let(:subject) do
+        Kitchen::Thing::SubclassDefaults.new(config).finalize_config!(instance)
+      end
+
+      it "contains defaults from superclass" do
+        subject[:beans].must_equal "kidney"
+        subject[:tunables]["flimflam"].must_equal "positate"
+        subject[:edible].must_equal true
+        subject[:yea].must_equal "ya"
+      end
+
+      it "uses provided config over default config" do
+        config[:beans] = "pinto"
+        config[:edible] = false
+
+        subject[:beans].must_equal "pinto"
+        subject[:edible].must_equal false
+        subject[:yea].must_equal "ya"
+        subject[:beans_url].must_equal "http://gim.me/pinto"
+      end
+
+      it "uses its own default_config over inherited default_config" do
+        subject[:fetch_url].must_equal "http://no.beans"
+        subject[:command].must_equal "wget http://gim.me/kidney"
+      end
+    end
+
+    describe "using static required_config statements" do
+
+      let(:config) do
+        { :a_default => true }
+      end
+
+      let(:subject) do
+        Kitchen::Thing::StaticDefaults.new(config).finalize_config!(instance)
+      end
+
+      it "uses a value when provided" do
+        config[:need_it] = "okay"
+
+        subject[:need_it].must_equal "okay"
+      end
+
+      it "without a block, raises a UserError if attr is nil" do
+        config[:need_it] = nil
+
+        begin
+          subject
+          flunk "UserError must be raised"
+        rescue Kitchen::UserError => e
+          attr = "Kitchen::Thing::StaticDefaults<instance>#config[:need_it]"
+          e.message.must_equal "#{attr} cannot be blank"
+        end
+      end
+
+      it "without a block, raises a UserError if attr is an empty string" do
+        config[:need_it] = ""
+
+        begin
+          subject
+          flunk "UserError must be raised"
+        rescue Kitchen::UserError => e
+          attr = "Kitchen::Thing::StaticDefaults<instance>#config[:need_it]"
+          e.message.must_equal "#{attr} cannot be blank"
+        end
+      end
+
+      it "with a block, it is saved and invoked" do
+        config[:need_it] = "okay"
+        config[:no_nuts] = "nuts"
+
+        begin
+          subject
+          flunk "UserError must be raised"
+        rescue Kitchen::UserError => e
+          e.message.must_equal "NO NUTS FOR no_nuts!"
+        end
+      end
+    end
+
+    describe "using inherited static require_config statements" do
+
+      let(:subject) do
+        Kitchen::Thing::SubclassDefaults.new(config).finalize_config!(instance)
+      end
+
+      it "contains required config from superclass" do
+        config[:a_default] = nil
+        config[:need_it] = nil
+
+        begin
+          subject
+          flunk "UserError must be raised"
+        rescue Kitchen::UserError => e
+          attr = "Kitchen::Thing::StaticDefaults<instance>#config[:need_it]"
+          e.message.must_equal "#{attr} cannot be blank"
+        end
+      end
+
+      it "uses its own require_config over inherited require_config" do
+        config[:need_it] = true
+        config[:a_default] = nil
+
+        begin
+          subject
+          flunk "UserError must be raised"
+        rescue Kitchen::UserError => e
+          e.message.must_equal "Overriding a_default is fun"
+        end
+      end
+    end
+
+    describe "using static expand_path_for statements" do
+
+      let(:config) do
+        { :need_it => "a", :a_default => "b", :kitchen_root => "/tmp/yo/self" }
+      end
+
+      let(:subject) do
+        Kitchen::Thing::StaticDefaults.new(config).finalize_config!(instance)
+      end
+
+      it "expands a default value" do
+        subject[:success_path].must_equal "/tmp/yo/self/success"
+      end
+
+      it "uses provided config over default_config" do
+        config[:success_path] = "mine"
+
+        subject[:success_path].must_equal "/tmp/yo/self/mine"
+      end
+
+      it "leaves a full path expanded" do
+        config[:success_path] = "/the/other/one"
+
+        subject[:success_path].must_equal "/the/other/one"
+      end
+
+      it "doesn't expand path with a falsy expand_path_for value" do
+        config[:relative_path] = "./rel"
+
+        subject[:relative_path].must_equal "./rel"
+      end
+
+      it "expands a path if a lambda returns truthy" do
+        config[:something_else] = "is_set"
+        config[:complex_path] = "./complex"
+
+        subject[:complex_path].must_equal "/tmp/yo/self/complex"
+      end
+    end
+
+    describe "using inherited static expand_path_for statements" do
+
+      let(:config) do
+        { :need_it => "a", :a_default => "please", :kitchen_root => "/rooty" }
+      end
+
+      let(:subject) do
+        Kitchen::Thing::SubclassDefaults.new(config).finalize_config!(instance)
+      end
+
+      it "contains expand_path_for from superclass" do
+        subject[:success_path].must_equal "/rooty/success"
+      end
+
+      it "uses its own expand_path_for over inherited expand_path_for" do
+        config[:another_path] = "./pp"
+
+        subject[:another_path].must_equal "./pp"
+      end
+    end
+
+    it "#config_keys returns an array of config key names" do
+      subject = Kitchen::Thing::Tiny.new(:ice_cream => "dragon")
+
+      subject.config_keys.sort.must_equal [:ice_cream]
+    end
+  end
+
+  describe "#diagnose" do
+
+    it "returns an empty hash for no config" do
+      subject.diagnose.must_equal Hash.new
+    end
+
+    it "returns a hash of config" do
+      config[:alpha] = "beta"
+      subject.diagnose.must_equal(:alpha => "beta")
+    end
+
+    it "returns a hash with sorted keys" do
+      config[:zebra] = true
+      config[:elephant] = true
+
+      subject.diagnose.keys.must_equal [:elephant, :zebra]
+    end
+  end
+
+  describe "#calculate_path" do
+
+    let(:config) do
+      { :test_base_path => "/the/basest" }
+    end
+
+    let(:suite) do
+      stub(:name => "ultimate")
+    end
+
+    let(:instance) do
+      stub(:name => "coolbeans", :to_str => "<instance>", :suite => suite)
+    end
+
+    let(:subject) do
+      Kitchen::Thing::Tiny.new(config).finalize_config!(instance)
+    end
+
+    before do
+      FakeFS.activate!
+    end
+
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+
+    describe "for directories" do
+
+      before do
+        FileUtils.mkdir_p(File.join(Dir.pwd, "winner"))
+        FileUtils.mkdir_p("/the/basest/winner")
+        FileUtils.mkdir_p("/the/basest/ultimate/winner")
+      end
+
+      it "prefers a path containing base path and suite name if it exists" do
+        subject.calculate_path("winner").
+          must_equal "/the/basest/ultimate/winner"
+      end
+
+      it "prefers a path containing base path if it exists" do
+        FileUtils.rm_rf("/the/basest/ultimate/winner")
+
+        subject.calculate_path("winner").must_equal "/the/basest/winner"
+      end
+
+      it "prefers a path in the current working directory if it exists" do
+        FileUtils.rm_rf("/the/basest/ultimate/winner")
+        FileUtils.rm_rf("/the/basest/winner")
+        pwd_dir = File.join(Dir.pwd, "winner")
+
+        subject.calculate_path("winner").must_equal pwd_dir
+      end
+
+      it "raises a UserError if test_base_path key is not set" do
+        config.delete(:test_base_path)
+
+        proc { subject.calculate_path("winner") }.must_raise Kitchen::UserError
+      end
+
+      it "uses a custom base path" do
+        FileUtils.mkdir_p("/custom/ultimate/winner")
+
+        subject.calculate_path("winner", :base_path => "/custom").
+          must_equal "/custom/ultimate/winner"
+      end
+    end
+
+    describe "for files" do
+
+      before do
+        FileUtils.mkdir_p(Dir.pwd)
+        FileUtils.touch(File.join(Dir.pwd, "winner"))
+        FileUtils.mkdir_p("/the/basest")
+        FileUtils.touch(File.join("/the/basest", "winner"))
+        FileUtils.mkdir_p("/the/basest/ultimate")
+        FileUtils.touch(File.join("/the/basest/ultimate", "winner"))
+      end
+
+      it "prefers a path containing base path and suite name if it exists" do
+        subject.calculate_path("winner", :type => :file).
+          must_equal "/the/basest/ultimate/winner"
+      end
+
+      it "prefers a path containing base path if it exists" do
+        FileUtils.rm_rf("/the/basest/ultimate/winner")
+
+        subject.calculate_path("winner", :type => :file).
+          must_equal "/the/basest/winner"
+      end
+
+      it "prefers a path in the current working directory if it exists" do
+        FileUtils.rm_rf("/the/basest/ultimate/winner")
+        FileUtils.rm_rf("/the/basest/winner")
+        pwd_dir = File.join(Dir.pwd, "winner")
+
+        subject.calculate_path("winner", :type => :file).must_equal pwd_dir
+      end
+
+      it "raises a UserError if test_base_path key is not set" do
+        config.delete(:test_base_path)
+
+        proc { subject.calculate_path("winner") }.must_raise Kitchen::UserError
+      end
+
+      it "uses a custom base path" do
+        FileUtils.mkdir_p("/custom/ultimate")
+        FileUtils.touch(File.join("/custom/ultimate", "winner"))
+
+        subject.calculate_path("winner", :type => :file, :base_path => "/custom").
+          must_equal "/custom/ultimate/winner"
+      end
+    end
+  end
+end