test-kitchen 1.23.3 → 1.23.4

data/spec/kitchen/diagnostic_spec.rb

@@ -1,128 +0,0 @@
-# -*- 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 "kitchen/diagnostic"
-
-describe Kitchen::Diagnostic do
-  let(:loader) do
-    stub(diagnose: { who: "loader" })
-  end
-
-  let(:instances) do
-    [
-      stub(
-        name: "i1",
-        diagnose: { stuff: "sup" },
-        diagnose_plugins: {
-          driver: { name: "driva", a: "b" },
-          provisioner: { name: "prov", c: "d" },
-          transport: { name: "transa", e: "f" },
-          verifier: { name: "verve", g: "h" },
-        }
-      ),
-      stub(
-        name: "i2",
-        diagnose: { stuff: "yo" },
-        diagnose_plugins: {
-          driver: { name: "driva", a: "b" },
-          provisioner: { name: "presto", i: "j" },
-          transport: { name: "tressa", k: "l" },
-          verifier: { name: "verve", g: "h" },
-        }
-      ),
-    ]
-  end
-
-  it "#read returns a Hash" do
-    Kitchen::Diagnostic.new.read.must_be_instance_of Hash
-  end
-
-  it "#read returns the version of Test Kitchen" do
-    Kitchen::Diagnostic.new.read["kitchen_version"].must_equal Kitchen::VERSION
-  end
-
-  it "#read returns a timestamp in UTC" do
-    Time.stubs(:now).returns(Time.at(0))
-
-    Kitchen::Diagnostic.new.read["timestamp"]
-      .must_equal "1970-01-01 00:00:00 UTC"
-  end
-
-  it "#read doesn't return a loader hash if not given one" do
-    Kitchen::Diagnostic.new.read.key?("loader").must_equal false
-  end
-
-  it "#read returns the loader's diganose hash if a loader is present" do
-    Kitchen::Diagnostic.new(loader: loader)
-                       .read["loader"].must_equal("who" => "loader")
-  end
-
-  it "#read returns an error hash for loader if error hash is passed in" do
-    Kitchen::Diagnostic.new(loader: { error: "damn" })
-                       .read["loader"].must_equal("error" => "damn")
-  end
-
-  it "#read returns the unique set of plugins' diagnose hash if :plugins is set" do
-    Kitchen::Diagnostic.new(instances: instances, plugins: true)
-                       .read["plugins"]
-      .must_equal(
-        "driver" => {
-          "driva" => { "a" => "b" },
-        },
-        "provisioner" => {
-          "prov" => { "c" => "d" },
-          "presto" => { "i" => "j" },
-        },
-        "transport" => {
-          "transa" => { "e" => "f" },
-          "tressa" => { "k" => "l" },
-        },
-        "verifier" => {
-          "verve" => { "g" => "h" },
-        }
-      )
-  end
-
-  it "#read returns an empty plugins hash if no instances were given" do
-    Kitchen::Diagnostic.new(plugins: true)
-                       .read["plugins"].must_equal Hash.new
-  end
-
-  it "#read returns an empty instances hash if no instances were given" do
-    Kitchen::Diagnostic.new.read["instances"].must_equal Hash.new
-  end
-
-  it "#read returns an error hash for plugins if error hash is passed in" do
-    Kitchen::Diagnostic.new(
-      instances: { error: "shoot" }, plugins: true
-    ).read["plugins"].must_equal("error" => "shoot")
-  end
-
-  it "#read returns the instances' diganose hashes if instances are present" do
-    Kitchen::Diagnostic.new(instances: instances)
-                       .read["instances"]
-      .must_equal("i1" => { "stuff" => "sup" }, "i2" => { "stuff" => "yo" })
-  end
-
-  it "#read returns an error hash for instances if error hash is passed in" do
-    Kitchen::Diagnostic.new(instances: { error: "shoot" })
-                       .read["instances"].must_equal("error" => "shoot")
-  end
-end

data/spec/kitchen/driver/base_spec.rb

@@ -1,132 +0,0 @@
-# -*- 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"
-
-module Kitchen
-  module Driver
-    class Speedy < Base
-    end
-
-    class Dodgy < Base
-      no_parallel_for :setup
-    end
-
-    class Slow < Base
-      no_parallel_for :create, :destroy
-      no_parallel_for :verify
-    end
-  end
-end
-
-describe Kitchen::Driver::Base do
-  let(:logged_output) { StringIO.new }
-  let(:logger)        { Logger.new(logged_output) }
-  let(:config)        { Hash.new }
-  let(:state)         { Hash.new }
-
-  let(:busser) do
-    stub(setup_cmd: "setup", sync_cmd: "sync", run_cmd: "run")
-  end
-
-  let(:instance) do
-    stub(
-      name: "coolbeans",
-      logger: logger,
-      busser: busser,
-      to_str: "instance"
-    )
-  end
-
-  let(:driver) do
-    Kitchen::Driver::Base.new(config).finalize_config!(instance)
-  end
-
-  it "#instance returns its instance" do
-    driver.instance.must_equal instance
-  end
-
-  it "#puts calls logger.info" do
-    driver.send(:puts, "yo")
-
-    logged_output.string.must_match(/I, /)
-    logged_output.string.must_match(/yo\n/)
-  end
-
-  it "#print calls logger.info" do
-    driver.send(:print, "yo")
-
-    logged_output.string.must_match(/I, /)
-    logged_output.string.must_match(/yo\n/)
-  end
-
-  [:create, :setup, :verify, :destroy].each do |action|
-    it "has a #{action} method that takes state" do
-      # TODO: revert back
-      # state = Hash.new
-      # driver.public_send(action, state).must_be_nil
-      driver.respond_to?(action)
-    end
-  end
-
-  describe ".pre_create_command" do
-    it "run command" do
-      Kitchen::Driver::Base.any_instance.stubs(:run_command).returns(true)
-
-      config[:pre_create_command] = "echo works 2&>1 > /dev/null"
-      driver.expects(:run_command).with("echo works 2&>1 > /dev/null")
-      driver.send(:pre_create_command)
-    end
-
-    it "error if cannot run" do
-      class ShellCommandFailed < Kitchen::ShellOut::ShellCommandFailed; end
-      Kitchen::Driver::Base.any_instance.stubs(:run_command).raises(ShellCommandFailed, "Expected process to exit with [0], but received '1'")
-
-      config[:pre_create_command] = "touch /this/dir/does/not/exist 2&>1 > /dev/null"
-      proc { driver.send(:pre_create_command) }.must_raise Kitchen::ActionFailed
-    end
-  end
-
-  describe ".no_parallel_for" do
-    it "registers no serial actions when none are declared" do
-      Kitchen::Driver::Speedy.serial_actions.must_be_nil
-    end
-
-    it "registers a single serial action method" do
-      Kitchen::Driver::Dodgy.serial_actions.must_equal [:setup]
-    end
-
-    it "registers multiple serial action methods" do
-      actions = Kitchen::Driver::Slow.serial_actions
-
-      actions.must_include :create
-      actions.must_include :verify
-      actions.must_include :destroy
-    end
-
-    it "raises a ClientError if value is not an action method" do
-      proc do
-        Class.new(Kitchen::Driver::Base) { no_parallel_for :telling_stories }
-      end.must_raise Kitchen::ClientError
-    end
-  end
-end

data/spec/kitchen/driver/dummy_spec.rb

@@ -1,193 +0,0 @@
-# -*- 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
-    Kitchen::Driver::Dummy.new(config).finalize_config!(instance)
-  end
-
-  it "driver api_version is 2" do
-    driver.diagnose_plugin[:api_version].must_equal 2
-  end
-
-  it "plugin_version is set to Kitchen::VERSION" do
-    driver.diagnose_plugin[:version].must_equal Kitchen::VERSION
-  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 "raises ActionFailed if :fail_create is set" do
-      config[:fail_create] = true
-
-      proc { driver.create(state) }.must_raise Kitchen::ActionFailed
-    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
-        # If exception is anything other than Kitchen::ActionFailed, this spec
-        # will fail
-        true
-      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 "#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 "raises ActionFailed if :fail_setup is set" do
-      config[:fail_setup] = true
-
-      proc { driver.setup(state) }.must_raise Kitchen::ActionFailed
-    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 "raises ActionFailed if :fail_verify is set" do
-      config[:fail_verify] = true
-
-      proc { driver.verify(state) }.must_raise Kitchen::ActionFailed
-    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 "raises ActionFailed if :fail_destroy is set" do
-      config[:fail_destroy] = true
-
-      proc { driver.destroy(state) }.must_raise Kitchen::ActionFailed
-    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