test-kitchen 0.7.0 → 1.0.0.alpha.0

data/spec/kitchen/config_spec.rb

@@ -0,0 +1,201 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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'
+require 'kitchen/logging'
+require 'kitchen/collection'
+require 'kitchen/config'
+require 'kitchen/driver'
+require 'kitchen/instance'
+require 'kitchen/platform'
+require 'kitchen/suite'
+require 'kitchen/util'
+
+module Kitchen
+
+  class DummyLoader
+
+    def read
+      @data || Hash.new
+    end
+
+    def data=(hash)
+      @data = hash
+    end
+  end
+end
+
+describe Kitchen::Config do
+
+  let(:loader)  { Kitchen::DummyLoader.new }
+  let(:config)  { Kitchen::Config.new(:loader => loader) }
+
+  before do
+    FakeFS.activate!
+    FileUtils.mkdir_p("/tmp")
+  end
+
+  after do
+    FakeFS.deactivate!
+    FakeFS::FileSystem.clear
+  end
+
+  describe "#platforms" do
+
+    it "returns platforms loaded from a kitchen.yml" do
+      stub_data!({ :platforms => [{ :name => 'one' }, { :name => 'two' }] })
+
+      config.platforms.size.must_equal 2
+      config.platforms[0].name.must_equal 'one'
+      config.platforms[1].name.must_equal 'two'
+    end
+
+    it "returns an empty Array if no platforms are given" do
+      stub_data!({})
+
+      config.platforms.must_equal []
+    end
+  end
+
+  describe "#suites" do
+
+    it "returns suites loaded from a kitchen.yml" do
+      stub_data!({ :suites => [
+        { :name => 'one', :run_list => [] },
+        { :name => 'two', :run_list => [] },
+      ] })
+
+      config.suites.size.must_equal 2
+      config.suites[0].name.must_equal 'one'
+      config.suites[1].name.must_equal 'two'
+    end
+
+    it "returns an empty Array if no suites are given" do
+      stub_data!({})
+
+      config.suites.must_equal []
+    end
+
+    it "returns a suite with nil for data_bags_path by default" do
+      stub_data!({ :suites => [{ :name => 'one', :run_list => [] }] })
+      config.suites.first.data_bags_path.must_be_nil
+    end
+
+    it "retuns a suite with a common data_bags_path set" do
+      stub_data!({ :suites => [{ :name => 'one', :run_list => [] }] })
+      config.test_base_path = "/tmp/base"
+      FileUtils.mkdir_p "/tmp/base/data_bags"
+
+      config.suites.first.data_bags_path.must_equal "/tmp/base/data_bags"
+    end
+
+    it "retuns a suite with a suite-specific data_bags_path set" do
+      stub_data!({ :suites => [{ :name => 'cool', :run_list => [] }] })
+      config.test_base_path = "/tmp/base"
+      FileUtils.mkdir_p "/tmp/base/cool/data_bags"
+      config.suites.first.data_bags_path.must_equal "/tmp/base/cool/data_bags"
+    end
+
+    it "returns a suite with nil for roles_path by default" do
+      stub_data!({ :suites => [{ :name => 'one', :run_list => [] }] })
+      config.suites.first.roles_path.must_be_nil
+    end
+
+    it "returns a suite with a common roles_path set" do
+      stub_data!({ :suites => [{ :name => 'one', :run_list => [] }] })
+      config.test_base_path = "/tmp/base"
+      FileUtils.mkdir_p "/tmp/base/roles"
+      config.suites.first.roles_path.must_equal "/tmp/base/roles"
+    end
+
+    it "returns a suite with a suite-specific roles_path set" do
+      stub_data!({ :suites => [{ :name => 'mysuite', :run_list => [] }] })
+      config.test_base_path = "/tmp/base"
+      FileUtils.mkdir_p "/tmp/base/mysuite/roles"
+      config.suites.first.roles_path.must_equal "/tmp/base/mysuite/roles"
+    end
+  end
+
+  describe "#instances" do
+
+    it "returns instances loaded from a kitchen.yml" do
+      stub_data!({
+        :platforms => [
+          { :name => 'p1' },
+          { :name => 'p2' },
+        ],
+        :suites => [
+          { :name => 's1', :run_list => [] },
+          { :name => 's2', :run_list => [] },
+          { :name => 's3', :run_list => [], :excludes => ['p1'] }
+        ]
+      })
+      config.instances.size.must_equal 5
+      config.instances.map { |i| i.name }.must_equal %w{s1-p1 s1-p2 s2-p1 s2-p2 s3-p2}
+    end
+
+    it "returns an instance containing a driver instance" do
+      stub_data!({
+        :platforms => [{ :name => 'platform', :driver_plugin => 'dummy' }],
+        :suites => [{ :name => 'suite', :run_list => [] }]
+      })
+      config.instances.first.driver.must_be_instance_of Kitchen::Driver::Dummy
+    end
+
+    it "returns an instance with a driver initialized with kitchen_root" do
+      config.kitchen_root = "/tmp"
+      stub_data!({
+        :platforms => [{ :name => 'platform', :driver_plugin => 'dummy' }],
+        :suites => [{ :name => 'suite', :run_list => [] }]
+      })
+      config.instances.first.driver[:kitchen_root].must_equal "/tmp"
+    end
+
+    it "returns an instance with a driver initialized with passed in config" do
+      stub_data!({
+        :platforms => [
+          { :name => 'platform', :driver_plugin => 'dummy',
+            :driver_config => { :foo => 'bar' }
+          }
+        ],
+        :suites => [{ :name => 'suite', :run_list => [] }]
+      })
+      config.instances.first.driver[:foo].must_equal "bar"
+    end
+  end
+
+  describe "#log_level" do
+
+    it "returns a default log_level of info" do
+      config.log_level.must_equal :info
+    end
+
+    it "returns an overridden log_level" do
+      config.log_level = :error
+      config.log_level.must_equal :error
+    end
+  end
+
+  private
+
+  def stub_data!(hash)
+    loader.data = hash
+  end
+end

data/spec/kitchen/driver/dummy_spec.rb

@@ -0,0 +1,191 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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 'logger'
+require 'stringio'
+
+require 'kitchen/driver/dummy'
+
+describe Kitchen::Driver::Dummy do
+
+  let(:logged_output) { StringIO.new }
+  let(:logger)        { Logger.new(logged_output) }
+  let(:config)        { Hash.new }
+  let(:state)         { Hash.new }
+
+  let(:instance) do
+    stub(:name => "coolbeans", :logger => logger, :to_str => "instance")
+  end
+
+  let(:driver) do
+    d = Kitchen::Driver::Dummy.new(config)
+    d.instance = instance
+    d
+  end
+
+  describe "default_config" do
+
+    it "sets :sleep to 0 by default" do
+      driver[:sleep].must_equal 0
+    end
+
+    it "sets :random_failure to false by default" do
+      driver[:random_failure].must_equal false
+    end
+  end
+
+  describe "#create" do
+
+    it "sets :my_id to a unique value as an example" do
+      driver.create(state)
+
+      state[:my_id].must_match /^coolbeans-/
+    end
+
+    it "calls sleep if :sleep value is greater than 0" do
+      config[:sleep] = 12.5
+      driver.expects(:sleep).with(12.5).returns(true)
+
+      driver.create(state)
+    end
+
+    it "randomly raises ActionFailed if :random_failure is set" do
+      config[:random_failure] = true
+      driver.stubs(:randomly_fail?).returns(true)
+
+      proc { driver.create(state) }.must_raise Kitchen::ActionFailed
+    end
+
+    it "will only raise ActionFailed if :random_failure is set" do
+      config[:random_failure] = true
+
+      begin
+        driver.create(state)
+      rescue Kitchen::ActionFailed => ex
+        # If exception is anything other than Kitchen::ActionFailed, this spec
+        # will fail
+      end
+    end
+
+    it "logs a create event to INFO" do
+      driver.create(state)
+
+      logged_output.string.must_match /^.+ INFO .+ \[Dummy\] Create on .+$/
+    end
+  end
+
+  describe "#converge" do
+
+    it "calls sleep if :sleep value is greater than 0" do
+      config[:sleep] = 12.5
+      driver.expects(:sleep).with(12.5).returns(true)
+
+      driver.create(state)
+    end
+
+    it "randomly raises ActionFailed if :random_failure is set" do
+      config[:random_failure] = true
+      driver.stubs(:randomly_fail?).returns(true)
+
+      proc { driver.converge(state) }.must_raise Kitchen::ActionFailed
+    end
+
+    it "logs a converge event to INFO" do
+      driver.converge(state)
+
+      logged_output.string.must_match /^.+ INFO .+ \[Dummy\] Converge on .+$/
+    end
+  end
+
+  describe "#setup" do
+
+    it "calls sleep if :sleep value is greater than 0" do
+      config[:sleep] = 12.5
+      driver.expects(:sleep).with(12.5).returns(true)
+
+      driver.setup(state)
+    end
+
+    it "randomly raises ActionFailed if :random_failure is set" do
+      config[:random_failure] = true
+      driver.stubs(:randomly_fail?).returns(true)
+
+      proc { driver.setup(state) }.must_raise Kitchen::ActionFailed
+    end
+
+    it "logs a setup event to INFO" do
+      driver.setup(state)
+
+      logged_output.string.must_match /^.+ INFO .+ \[Dummy\] Setup on .+$/
+    end
+  end
+
+  describe "#verify" do
+
+    it "calls sleep if :sleep value is greater than 0" do
+      config[:sleep] = 12.5
+      driver.expects(:sleep).with(12.5).returns(true)
+
+      driver.verify(state)
+    end
+
+    it "randomly raises ActionFailed if :random_failure is set" do
+      config[:random_failure] = true
+      driver.stubs(:randomly_fail?).returns(true)
+
+      proc { driver.verify(state) }.must_raise Kitchen::ActionFailed
+    end
+
+    it "logs a verify event to INFO" do
+      driver.verify(state)
+
+      logged_output.string.must_match /^.+ INFO .+ \[Dummy\] Verify on .+$/
+    end
+  end
+
+  describe "#destroy" do
+
+    it "removes :my_id from the state hash" do
+      state[:my_id] = "90210"
+      driver.destroy(state)
+
+      state[:my_id].must_be_nil
+    end
+
+    it "calls sleep if :sleep value is greater than 0" do
+      config[:sleep] = 12.5
+      driver.expects(:sleep).with(12.5).returns(true)
+
+      driver.verify(state)
+    end
+
+    it "randomly raises ActionFailed if :random_failure is set" do
+      config[:random_failure] = true
+      driver.stubs(:randomly_fail?).returns(true)
+
+      proc { driver.destroy(state) }.must_raise Kitchen::ActionFailed
+    end
+
+    it "logs a destroy event to INFO" do
+      driver.destroy(state)
+
+      logged_output.string.must_match /^.+ INFO .+ \[Dummy\] Destroy on .+$/
+    end
+  end
+end

data/spec/kitchen/instance_spec.rb

@@ -0,0 +1,162 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, 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 'logger'
+require 'stringio'
+
+require 'kitchen/logging'
+require 'kitchen/instance'
+require 'kitchen/driver'
+require 'kitchen/driver/dummy'
+require 'kitchen/platform'
+require 'kitchen/suite'
+
+describe Kitchen::Instance do
+
+  let(:suite) do
+    Kitchen::Suite.new({ :name => 'suite',
+      :run_list => 'suite_list', :attributes => { :s => 'ss' } })
+  end
+
+  let(:platform) do
+    Kitchen::Platform.new({ :name => 'platform',
+      :run_list => 'platform_list', :attributes => { :p => 'pp' } })
+  end
+
+  let(:driver) { Kitchen::Driver::Dummy.new({}) }
+
+  let(:opts) do
+    { :suite => suite, :platform => platform, :driver => driver }
+  end
+
+  let(:instance) { Kitchen::Instance.new(opts) }
+
+  before do
+    Celluloid.logger = Logger.new(StringIO.new)
+  end
+
+  it "raises an ArgumentError if suite is missing" do
+    opts.delete(:suite)
+    proc { Kitchen::Instance.new(opts) }.must_raise Kitchen::ClientError
+  end
+
+  it "raises an ArgumentError if platform is missing" do
+    opts.delete(:platform)
+    proc { Kitchen::Instance.new(opts) }.must_raise Kitchen::ClientError
+  end
+
+  it "returns suite" do
+    instance.suite.must_equal suite
+  end
+
+  it "returns platform" do
+    instance.platform.must_equal platform
+  end
+
+  describe "#name" do
+
+    def combo(suite_name, platform_name)
+      opts[:suite] = Kitchen::Suite.new(
+        :name => suite_name, :run_list => []
+      )
+      opts[:platform] = Kitchen::Platform.new(
+        :name => platform_name
+      )
+      Kitchen::Instance.new(opts)
+    end
+
+    it "combines the suite and platform names with a dash" do
+      combo('suite', 'platform').name.must_equal "suite-platform"
+    end
+
+    it "squashes periods" do
+      combo('suite.ness', 'platform').name.must_equal "suiteness-platform"
+      combo('suite', 'platform.s').name.must_equal "suite-platforms"
+      combo('s.s.', '.p.p').name.must_equal "ss-pp"
+    end
+
+    it "transforms underscores to dashes" do
+      combo('suite_ness', 'platform').name.must_equal "suite-ness-platform"
+      combo('suite', 'platform-s').name.must_equal "suite-platform-s"
+      combo('_s__s_', 'pp_').name.must_equal "-s--s--pp-"
+    end
+  end
+
+  describe "#run_list" do
+
+    def combo(suite_list, platform_list)
+      opts[:suite] = Kitchen::Suite.new(
+        :name => 'suite', :run_list => suite_list
+      )
+      opts[:platform] = Kitchen::Platform.new(
+        :name => 'platform', :run_list => platform_list
+      )
+      Kitchen::Instance.new(opts)
+    end
+
+    it "combines the platform then suite run_lists" do
+      combo(%w{s1 s2}, %w{p1 p2}).run_list.must_equal %w{p1 p2 s1 s2}
+    end
+
+    it "uses the suite run_list only when platform run_list is empty" do
+      combo(%w{sa sb}, nil).run_list.must_equal %w{sa sb}
+    end
+
+    it "returns an emtpy Array if both run_lists are empty" do
+      combo([], nil).run_list.must_equal []
+    end
+  end
+
+  describe "#attributes" do
+
+    def combo(suite_attrs, platform_attrs)
+      opts[:suite] = Kitchen::Suite.new(
+        :name => 'suite', :run_list => [], :attributes => suite_attrs
+      )
+      opts[:platform] = Kitchen::Platform.new(
+        :name => 'platform', :attributes => platform_attrs
+      )
+      Kitchen::Instance.new(opts)
+    end
+
+    it "merges suite and platform hashes together" do
+      combo(
+        { :suite => { :s1 => 'sv1' } },
+        { :suite => { :p1 => 'pv1' }, :platform => 'pp' }
+      ).attributes.must_equal({
+          :suite => { :s1 => 'sv1', :p1 => 'pv1' },
+          :platform => 'pp'
+        })
+    end
+
+    it "merges suite values over platform values" do
+      combo(
+        { :common => { :c1 => 'xxx' } },
+        { :common => { :c1 => 'cv1', :c2 => 'cv2' } },
+      ).attributes.must_equal({
+          :common => { :c1 => 'xxx', :c2 => 'cv2' }
+        })
+    end
+  end
+
+  it "#dna combines attributes with the run_list" do
+    instance.dna.must_equal({ :s => 'ss', :p => 'pp',
+      :run_list => ['platform_list', 'suite_list'] })
+  end
+end