test-kitchen 1.23.3 → 1.23.4

data/spec/kitchen/transport_spec.rb

@@ -1,106 +0,0 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Matt Wrock (<matt@mattwrock.com>)
-#
-# Copyright (C) 2014, Matt Wrock
-#
-# 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/configurable"
-require "kitchen/errors"
-require "kitchen/logging"
-require "kitchen/transport"
-require "kitchen/transport/base"
-
-module Kitchen
-  module Transport
-    class Coolbeans < Kitchen::Transport::Base
-    end
-
-    class ItDepends < Kitchen::Transport::Base
-      attr_reader :verify_call_count
-
-      def initialize(config = {})
-        @verify_call_count = 0
-        super
-      end
-
-      def verify_dependencies
-        @verify_call_count += 1
-      end
-    end
-
-    class UnstableDepends < Kitchen::Transport::Base
-      def verify_dependencies
-        raise UserError, "Oh noes, you don't have software!"
-      end
-    end
-  end
-end
-
-describe Kitchen::Transport do
-  describe ".for_plugin" do
-    before do
-      Kitchen::Transport.stubs(:require).returns(true)
-    end
-
-    it "returns a transport object of the correct class" do
-      transport = Kitchen::Transport.for_plugin("coolbeans", {})
-
-      transport.must_be_kind_of Kitchen::Transport::Coolbeans
-    end
-
-    it "returns a transport initialized with its config" do
-      transport = Kitchen::Transport.for_plugin("coolbeans", foo: "bar")
-
-      transport[:foo].must_equal "bar"
-    end
-
-    it "calls #verify_dependencies on the transport object" do
-      transport = Kitchen::Transport.for_plugin("it_depends", {})
-
-      transport.verify_call_count.must_equal 1
-    end
-
-    it "calls #verify_dependencies once per transport require" do
-      Kitchen::Transport.stubs(:require).returns(true, false)
-      transport1 = Kitchen::Transport.for_plugin("it_depends", {})
-      transport1.verify_call_count.must_equal 1
-      transport2 = Kitchen::Transport.for_plugin("it_depends", {})
-
-      transport2.verify_call_count.must_equal 0
-    end
-
-    it "raises ClientError if the transport could not be required" do
-      Kitchen::Transport.stubs(:require).raises(LoadError)
-
-      proc { Kitchen::Transport.for_plugin("coolbeans", {}) }
-        .must_raise Kitchen::ClientError
-    end
-
-    it "raises ClientError if the transport's class constant was not found" do
-      # pretend require worked
-      Kitchen::Transport.stubs(:require).returns(true)
-
-      proc { Kitchen::Transport.for_plugin("nope", {}) }
-        .must_raise Kitchen::ClientError
-    end
-
-    it "raises UserError if #verify_dependencies failes" do
-      proc { Kitchen::Transport.for_plugin("unstable_depends", {}) }
-        .must_raise Kitchen::UserError
-    end
-  end
-end

data/spec/kitchen/util_spec.rb

@@ -1,250 +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 "logger"
-
-require "kitchen/util"
-
-describe Kitchen::Util do
-  describe ".to_logger_level" do
-    it "returns nil for invalid symbols" do
-      Kitchen::Util.to_logger_level(:nope).must_be_nil
-    end
-
-    %w{debug info warn error fatal}.each do |level|
-      it "returns Logger::#{level.upcase} for :#{level} input" do
-        Kitchen::Util.to_logger_level(level.to_sym)
-                     .must_equal Logger.const_get(level.upcase)
-      end
-    end
-  end
-
-  describe ".from_logger_level" do
-    it "returns :fatal for invalid symbols" do
-      Kitchen::Util.from_logger_level("nope").must_equal :fatal
-    end
-
-    %w{debug info warn error fatal}.each do |level|
-      it "returns :#{level} for Logger::#{level.upcase} input" do
-        Kitchen::Util.from_logger_level(Logger.const_get(level.upcase))
-                     .must_equal(level.to_sym)
-      end
-    end
-  end
-
-  describe ".symbolized_hash" do
-    it "returns itself if not a hash" do
-      obj = Object.new
-      Kitchen::Util.symbolized_hash(obj).must_equal obj
-    end
-
-    it "preserves a symbolized hash" do
-      hash = { one: [{ two: "three" }] }
-      Kitchen::Util.symbolized_hash(hash).must_equal hash
-    end
-
-    it "converts string keys into symbols" do
-      Kitchen::Util
-        .symbolized_hash("one" => [{ "two" => :three, :four => "five" }])
-        .must_equal(one: [{ two: :three, four: "five" }])
-    end
-  end
-
-  describe ".stringified_hash" do
-    it "returns itself if not a hash" do
-      obj = Object.new
-      Kitchen::Util.stringified_hash(obj).must_equal obj
-    end
-
-    it "preserves a stringified hash" do
-      hash = { "one" => [{ "two" => "three" }] }
-      Kitchen::Util.stringified_hash(hash).must_equal hash
-    end
-
-    it "converts symbol keys into strings" do
-      Kitchen::Util
-        .stringified_hash(one: [{ :two => :three, "four" => "five" }])
-        .must_equal("one" => [{ "two" => :three, "four" => "five" }])
-    end
-  end
-
-  describe ".duration" do
-    it "turns nil into a zero" do
-      Kitchen::Util.duration(nil).must_equal "(0m0.00s)"
-    end
-
-    it "formats seconds to 2 digits" do
-      Kitchen::Util.duration(60).must_equal "(1m0.00s)"
-    end
-
-    it "formats large values into minutes and seconds" do
-      Kitchen::Util.duration(48_033).must_equal "(800m33.00s)"
-    end
-  end
-
-  describe ".wrap_unix_command" do
-    it "returns the wrapped command" do
-    end
-
-    it "returns a false if command is nil" do
-      Kitchen::Util.wrap_command(nil).must_equal("sh -c '\nfalse\n'")
-    end
-
-    it "returns a true if command string is empty" do
-      Kitchen::Util.wrap_command("yoyo").must_equal("sh -c '\nyoyo\n'")
-    end
-
-    it "handles a command string with a trailing newline" do
-      Kitchen::Util.wrap_command("yep\n").must_equal("sh -c '\nyep\n'")
-    end
-  end
-
-  describe ".outdent!" do
-    it "modifies the argument string in place, destructively" do
-      string = "yep"
-
-      Kitchen::Util.outdent!(string).object_id.must_equal string.object_id
-    end
-
-    it "returns the same string if no leading whitespace exists" do
-      string = "one\ntwo\nthree"
-
-      Kitchen::Util.outdent!(string).must_equal "one\ntwo\nthree"
-    end
-
-    it "strips same amount of leading whitespace as found on first line" do
-      string = "  one\n    two\n      three\nfour"
-
-      Kitchen::Util.outdent!(string).must_equal "one\n  two\n    three\nfour"
-    end
-  end
-
-  describe ".shell_helpers" do
-    %w{
-      exists do_wget do_curl do_fetch do_perl do_python do_download
-    }.each do |func|
-      it "contains a #{func} shell function" do
-        Kitchen::Util.shell_helpers.must_match "#{func}() {"
-      end
-    end
-
-    it "does not contain bare single quotes" do
-      Kitchen::Util.shell_helpers.wont_match "'"
-    end
-
-    def regexify(str)
-      Regexp.new("^ +" + Regexp.escape(str) + "$")
-    end
-  end
-
-  describe ".list_directory" do
-    before do
-      @root = Dir.mktmpdir
-      FileUtils.touch(File.join(@root, "foo"))
-      Dir.mkdir(File.join(@root, "bar"))
-      FileUtils.touch(File.join(@root, ".foo"))
-      FileUtils.touch(File.join(@root, "bar", "baz"))
-      FileUtils.touch(File.join(@root, "bar", ".baz"))
-    end
-
-    after do
-      FileUtils.remove_entry(@root)
-    end
-
-    it "returns [] when the directory does not exist" do
-      Kitchen::Util.list_directory(File.join(@root, "notexist")).must_equal []
-    end
-
-    it "lists one level with no dot files by default" do
-      listed = Kitchen::Util.list_directory(@root)
-      expected = %w{
-        foo
-        bar
-      }.map { |f| File.join(@root, f) }
-      (listed - expected).must_equal []
-      (expected - listed).must_equal []
-    end
-
-    it "matches dot files only when include_dot" do
-      listed = Kitchen::Util.list_directory(@root, include_dot: true)
-      expected = [
-        "foo",
-        ".foo",
-        "bar",
-      ].map { |f| File.join(@root, f) }
-      (listed - expected).must_equal []
-      (expected - listed).must_equal []
-    end
-
-    it "recusivly lists only when recurse" do
-      listed = Kitchen::Util.list_directory(@root, recurse: true)
-      expected = [
-        "foo",
-        "bar",
-        "bar/baz",
-      ].map { |f| File.join(@root, f) }
-      (listed - expected).must_equal []
-      (expected - listed).must_equal []
-    end
-
-    it "recusivly lists and provides dots when recurse and include_dot" do
-      listed = Kitchen::Util.list_directory(@root, recurse: true, include_dot: true)
-      expected = [
-        "foo",
-        ".foo",
-        "bar",
-        "bar/baz",
-        "bar/.",
-        "bar/.baz",
-      ].map { |f| File.join(@root, f) }
-      (listed - expected).must_equal []
-      (expected - listed).must_equal []
-    end
-  end
-
-  describe ".safe_glob" do
-    before do
-      @root = Dir.mktmpdir
-      FileUtils.touch(File.join(@root, "foo"))
-      Dir.mkdir(File.join(@root, "bar"))
-      FileUtils.touch(File.join(@root, "foo"))
-      FileUtils.touch(File.join(@root, "foo.rb"))
-      FileUtils.touch(File.join(@root, "bar", "baz.rb"))
-    end
-
-    after do
-      FileUtils.remove_entry(@root)
-    end
-
-    it "globs without parameters" do
-      Kitchen::Util.safe_glob(@root, "**/*").must_equal Dir.glob(File.join(@root, "**/*"))
-    end
-
-    it "globs with parameters" do
-      Kitchen::Util.safe_glob(@root, "**/*", File::FNM_DOTMATCH).must_equal(
-        Dir.glob(File.join(@root, "**/*"), File::FNM_DOTMATCH))
-    end
-
-    it "globs a folder that does not exist" do
-      dne_dir = File.join(@root, "notexist")
-      Kitchen::Util.safe_glob(dne_dir, "**/*").must_equal Dir.glob(File.join(dne_dir, "**/*"))
-    end
-  end
-end

data/spec/kitchen/verifier/base_spec.rb

@@ -1,346 +0,0 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2015, 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_relative "../ssh_spec"
-
-require "logger"
-require "stringio"
-
-require "kitchen/verifier/base"
-require "kitchen/transport/base"
-
-module Kitchen
-  module Verifier
-    class TestingDummy < Kitchen::Verifier::Base
-      attr_reader :called_create_sandbox, :called_cleanup_sandbox
-
-      def install_command
-        "install"
-      end
-
-      def init_command
-        "init"
-      end
-
-      def prepare_command
-        "prepare"
-      end
-
-      def run_command
-        "run"
-      end
-
-      def create_sandbox
-        @called_create_sandbox = true
-      end
-
-      def cleanup_sandbox
-        @called_cleanup_sandbox = true
-      end
-
-      def sandbox_path
-        "/tmp/sandbox"
-      end
-    end
-  end
-end
-
-describe Kitchen::Verifier::Base do
-  let(:logged_output)   { StringIO.new }
-  let(:logger)          { Logger.new(logged_output) }
-  let(:platform)        { stub(os_type: nil, shell_type: nil) }
-  let(:suite)           { stub(name: "germany") }
-  let(:config)          { Hash.new }
-
-  let(:transport) do
-    t = mock("transport")
-    t.responds_like_instance_of(Kitchen::Transport::Base)
-    t
-  end
-
-  let(:instance) do
-    stub(
-      name: "coolbeans",
-      to_str: "instance",
-      logger: logger,
-      platform: platform,
-      suite: suite,
-      transport: transport
-    )
-  end
-
-  let(:verifier) do
-    Kitchen::Verifier::Base.new(config).finalize_config!(instance)
-  end
-
-  describe "configuration" do
-    describe "for unix operating systems" do
-      before { platform.stubs(:os_type).returns("unix") }
-
-      it ":sudo defaults to true" do
-        verifier[:sudo].must_equal true
-      end
-
-      it ":sudo_command defaults to sudo -E" do
-        verifier[:sudo_command].must_equal "sudo -E"
-      end
-
-      it ":root_path defaults to '/tmp/verifier'" do
-        verifier[:root_path].must_equal "/tmp/verifier"
-      end
-    end
-
-    describe "for windows operating systems" do
-      before { platform.stubs(:os_type).returns("windows") }
-
-      it ":sudo defaults to nil" do
-        verifier[:sudo].must_be_nil
-      end
-
-      it ":sudo_command defaults to nil" do
-        verifier[:sudo_command].must_be_nil
-      end
-
-      it ':root_path defaults to $env:TEMP\\verifier' do
-        verifier[:root_path].must_equal '$env:TEMP\\verifier'
-      end
-    end
-
-    it ":suite_name defaults to the passed in suite name" do
-      verifier[:suite_name].must_equal "germany"
-    end
-
-    it ":http_proxy defaults to nil" do
-      verifier[:http_proxy].must_be_nil
-    end
-
-    it ":http_proxys defaults to nil" do
-      verifier[:https_proxy].must_be_nil
-    end
-
-    it ":ftp_proxy defaults to nil" do
-      verifier[:ftp_proxy].must_be_nil
-    end
-  end
-
-  describe "#call" do
-    let(:state) { Hash.new }
-    let(:cmd)   { verifier.call(state) }
-
-    let(:connection) do
-      c = mock("transport_connection")
-      c.responds_like_instance_of(Kitchen::Transport::Base::Connection)
-      c
-    end
-
-    let(:verifier) do
-      Kitchen::Verifier::TestingDummy.new(config).finalize_config!(instance)
-    end
-
-    before do
-      FakeFS.activate!
-      FileUtils.mkdir_p(File.join(verifier.sandbox_path, "stuff"))
-      transport.stubs(:connection).yields(connection)
-      connection.stubs(:execute)
-      connection.stubs(:upload)
-    end
-
-    after do
-      FakeFS.deactivate!
-      FakeFS::FileSystem.clear
-    end
-
-    it "creates the sandbox" do
-      verifier.expects(:create_sandbox)
-
-      cmd
-    end
-
-    it "ensures that the sandbox is cleanup up" do
-      transport.stubs(:connection).raises
-      verifier.expects(:cleanup_sandbox)
-
-      begin
-        cmd
-      rescue # rubocop:disable Lint/HandleExceptions
-      end
-    end
-
-    it "yields a connection given the state" do
-      state[:a] = "b"
-      transport.expects(:connection).with(state).yields(connection)
-
-      cmd
-    end
-
-    it "invokes the verifier commands over the transport" do
-      order = sequence("order")
-      connection.expects(:execute).with("install").in_sequence(order)
-      connection.expects(:execute).with("init").in_sequence(order)
-      connection.expects(:execute).with("prepare").in_sequence(order)
-      connection.expects(:execute).with("run").in_sequence(order)
-
-      cmd
-    end
-
-    it "logs to info" do
-      cmd
-
-      logged_output.string
-                   .must_match(/INFO -- : Transferring files to instance$/)
-    end
-
-    it "uploads sandbox files" do
-      connection.expects(:upload).with(["/tmp/sandbox/stuff"], "/tmp/verifier")
-
-      cmd
-    end
-
-    it "logs to debug" do
-      cmd
-
-      logged_output.string.must_match(/DEBUG -- : Transfer complete$/)
-    end
-
-    it "raises an ActionFailed on transfer when TransportFailed is raised" do
-      connection.stubs(:upload)
-                .raises(Kitchen::Transport::TransportFailed.new("dang"))
-
-      proc { cmd }.must_raise Kitchen::ActionFailed
-    end
-
-    it "raises an ActionFailed on execute when TransportFailed is raised" do
-      connection.stubs(:execute)
-                .raises(Kitchen::Transport::TransportFailed.new("dang"))
-
-      proc { cmd }.must_raise Kitchen::ActionFailed
-    end
-  end
-
-  [:init_command, :install_command, :prepare_command, :run_command].each do |cmd|
-    it "has a #{cmd} method" do
-      verifier.public_send(cmd).must_be_nil
-    end
-  end
-
-  describe "sandbox" do
-    after do
-      begin
-        verifier.cleanup_sandbox
-      rescue # rubocop:disable Lint/HandleExceptions
-      end
-    end
-
-    it "raises ClientError if #sandbox_path is called before #create_sandbox" do
-      proc { verifier.sandbox_path }.must_raise Kitchen::ClientError
-    end
-
-    it "#create_sandbox creates a temporary directory" do
-      verifier.create_sandbox
-
-      File.directory?(verifier.sandbox_path).must_equal true
-      format("%o", File.stat(verifier.sandbox_path).mode)[1, 4]
-        .must_equal "0755"
-    end
-
-    it "#create_sandbox logs an info message" do
-      verifier.create_sandbox
-
-      logged_output.string.must_match info_line("Preparing files for transfer")
-    end
-
-    it "#create_sandbox logs a debug message" do
-      verifier.create_sandbox
-
-      logged_output.string
-                   .must_match debug_line_starting_with("Creating local sandbox in ")
-    end
-
-    it "#cleanup_sandbox deletes the sandbox directory" do
-      verifier.create_sandbox
-      verifier.cleanup_sandbox
-
-      File.directory?(verifier.sandbox_path).must_equal false
-    end
-
-    it "#cleanup_sandbox logs a debug message" do
-      verifier.create_sandbox
-      verifier.cleanup_sandbox
-
-      logged_output.string
-                   .must_match debug_line_starting_with("Cleaning up local sandbox in ")
-    end
-
-    def info_line(msg)
-      /^I, .* : #{Regexp.escape(msg)}$/
-    end
-
-    def debug_line_starting_with(msg)
-      /^D, .* : #{Regexp.escape(msg)}/
-    end
-  end
-
-  describe "#sudo" do
-    describe "with :sudo set" do
-      before { config[:sudo] = true }
-
-      it "prepends sudo command" do
-        verifier.send(:sudo, "wakka").must_equal("sudo -E wakka")
-      end
-
-      it "customizes sudo when :sudo_command is set" do
-        config[:sudo_command] = "blueto -Ohai"
-
-        verifier.send(:sudo, "wakka").must_equal("blueto -Ohai wakka")
-      end
-    end
-
-    describe "with :sudo falsey" do
-      before { config[:sudo] = false }
-
-      it "does not include sudo command" do
-        verifier.send(:sudo, "wakka").must_equal("wakka")
-      end
-
-      it "does not include sudo command, even when :sudo_command is set" do
-        config[:sudo_command] = "blueto -Ohai"
-
-        verifier.send(:sudo, "wakka").must_equal("wakka")
-      end
-    end
-  end
-
-  describe "#prefix_command" do
-    describe "with :command_prefix set" do
-      before { config[:command_prefix] = "my_prefix" }
-
-      it "prepends the command with the prefix" do
-        verifier.send(:prefix_command, "my_command").must_equal("my_prefix my_command")
-      end
-    end
-
-    describe "with :command_prefix unset" do
-      before { config[:command_prefix] = nil }
-
-      it "returns an unaltered command" do
-        verifier.send(:prefix_command, "my_command").must_equal("my_command")
-      end
-    end
-  end
-end