test-kitchen 0.7.0 → 1.0.0.alpha.0

data/lib/kitchen/collection.rb

@@ -0,0 +1,55 @@
+# -*- 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 'delegate'
+
+module Kitchen
+
+  # Delegate class which adds the ability to find single and multiple
+  # objects by their #name in an Array. Hey, it's better than monkey-patching
+  # Array, right?
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class Collection < SimpleDelegator
+
+    # Returns a single object by its name, or nil if none are found.
+    #
+    # @param name [String] name of object
+    # @return [Object] first match by name, or nil if none are found
+    def get(name)
+      __getobj__.find { |i| i.name == name }
+    end
+
+    # Returns a Collection of all objects whose #name is matched by the
+    # regular expression.
+    #
+    # @param regexp [Regexp] a regular expression pattern
+    # @return [Kitchen::Config::Collection<Object>] a new collection of
+    #   matched objects
+    def get_all(regexp)
+      Kitchen::Collection.new(__getobj__.find_all { |i| i.name =~ regexp })
+    end
+
+    # Returns an Array of names from the collection as strings.
+    #
+    # @return [Array<String>] array of name strings
+    def as_names
+      __getobj__.map { |i| i.name }
+    end
+  end
+end

data/lib/kitchen/color.rb

@@ -0,0 +1,46 @@
+# -*- 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.
+
+module Kitchen
+
+  module Color
+    ANSI = {
+      :reset => 0, :black => 30, :red => 31, :green => 32, :yellow => 33,
+      :blue => 34, :magenta => 35, :cyan => 36, :white => 37,
+      :bright_black => 30, :bright_red => 31, :bright_green => 32,
+      :bright_yellow => 33, :bright_blue => 34, :bright_magenta => 35,
+      :bright_cyan => 36, :bright_white => 37
+    }.freeze
+
+    COLORS = %w(
+      cyan yellow green magenta red blue bright_cyan bright_yellow
+      bright_green bright_magenta bright_red bright_blue
+    ).freeze
+
+    def self.escape(name)
+      return "" if name.nil?
+      return "" unless ansi = ANSI[name]
+      "\e[#{ansi}m"
+    end
+
+    def self.colorize(str, name)
+      color = escape(name)
+      color.empty? ? str : "#{color}#{str}#{escape(:reset)}"
+    end
+  end
+end

data/lib/kitchen/config.rb

@@ -0,0 +1,223 @@
+# -*- 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 'celluloid'
+require 'vendor/hash_recursive_merge'
+
+module Kitchen
+
+  # Base configuration class for Kitchen. This class exposes configuration such
+  # as the location of the Kitchen config file, instances, log_levels, etc.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class Config
+
+    attr_accessor :kitchen_root
+    attr_accessor :test_base_path
+    attr_accessor :log_level
+    attr_writer :supervised
+    attr_writer :platforms
+    attr_writer :suites
+
+    # Default driver plugin to use
+    DEFAULT_DRIVER_PLUGIN = "dummy".freeze
+
+    # Default base path which may contain `data_bags/` directories
+    DEFAULT_TEST_BASE_PATH = File.join(Dir.pwd, 'test/integration').freeze
+
+    # Creates a new configuration.
+    #
+    # @param [Hash] options configuration
+    # @option options [#read] :loader
+    # @option options [String] :kitchen_root
+    # @option options [String] :test_base_path
+    # @option options [Symbol] :log_level
+    # @option options [TrueClass,FalseClass] :supervised
+    def initialize(options = {})
+      @loader         = options[:loader] || Kitchen::Loader::YAML.new
+      @kitchen_root   = options[:kitchen_root] || Dir.pwd
+      @test_base_path = options[:test_base_path] || DEFAULT_TEST_BASE_PATH
+      @log_level      = options[:log_level] || Kitchen::DEFAULT_LOG_LEVEL
+      @supervised     = options[:supervised]
+    end
+
+    # @return [Array<Platform>] all defined platforms which will be used in
+    #   convergence integration
+    def platforms
+      @platforms ||= Collection.new(
+        Array(data[:platforms]).map { |hash| new_platform(hash) })
+    end
+
+    # @return [Array<Suite>] all defined suites which will be used in
+    #   convergence integration
+    def suites
+      @suites ||= Collection.new(
+        Array(data[:suites]).map { |hash| new_suite(hash) })
+    end
+
+    # @return [Array<Instance>] all instances, resulting from all platform and
+    #   suite combinations
+    def instances
+      @instances ||= build_instances
+    end
+
+    # Returns an InstanceActor for all instance names matched by the regexp,
+    # or all by default.
+    #
+    # @param [Regexp] a regular expression to match on instance names
+    # @return [Array<InstanceActor>] all instance actors matching the regexp
+    def instance_actors(regexp = nil)
+      result = regexp.nil? ? instances : instances.get_all(regexp)
+      Collection.new(result.map { |instance| actor_registry(instance) })
+    end
+
+    def supervised
+      @supervised.nil? ? @supervised = true : @supervised
+    end
+
+    private
+
+    def new_suite(hash)
+      path_hash = {
+        :data_bags_path => calculate_path("data_bags", hash[:name]),
+        :roles_path     => calculate_path("roles", hash[:name]),
+      }
+
+      Suite.new(hash.rmerge(path_hash))
+    end
+
+    def new_platform(hash)
+      Platform.new(hash)
+    end
+
+    def new_driver(hash)
+      hash[:driver_config] ||= Hash.new
+      hash[:driver_config][:kitchen_root] = kitchen_root
+
+      Driver.for_plugin(hash[:driver_plugin], hash[:driver_config])
+    end
+
+    def build_instances
+      results = []
+      filtered_instances = suites.product(platforms).delete_if do |arr|
+        arr[0].excludes.include?(arr[1].name)
+      end
+      filtered_instances.each_with_index do |arr, index|
+        results << new_instance(arr[0], arr[1], index)
+      end
+      Collection.new(results)
+    end
+
+    def new_instance(suite, platform, index)
+      platform_hash = platform_driver_hash(platform.name)
+      driver = new_driver(merge_driver_hash(platform_hash))
+
+      Instance.new(
+        :suite    => suite,
+        :platform => platform,
+        :driver   => driver,
+        :logger   => new_instance_logger(index)
+      )
+    end
+
+    def actor_registry(instance)
+      Celluloid::Actor[actor_key(instance)] || new_instance_actor(instance)
+    end
+
+    def actor_key(instance)
+      "#{object_id}__#{instance.name}"
+    end
+
+    def new_instance_actor(instance)
+      actor_name = actor_key(instance)
+
+      actor = if supervised
+        supervisor = InstanceActor.supervise_as(actor_name, instance)
+        actor = supervisor.actors.first
+        Kitchen.logger.debug("Supervising #{actor.to_str} with #{supervisor}")
+        actor
+      else
+        Celluloid::Actor[actor_name] = InstanceActor.new(instance)
+      end
+
+      manager.link(actor)
+
+      actor
+    end
+
+    def manager
+      @manager ||= Manager.new
+    end
+
+    def log_root
+      File.expand_path(File.join(kitchen_root, ".kitchen", "logs"))
+    end
+
+    def platform_driver_hash(platform_name)
+      h = data[:platforms].find { |p| p[:name] == platform_name } || Hash.new
+
+      h.select { |key, value| [:driver_plugin, :driver_config].include?(key) }
+    end
+
+    def new_instance_logger(index)
+      level = Util.to_logger_level(self.log_level)
+      color = Color::COLORS[index % Color::COLORS.size].to_sym
+
+      lambda do |name|
+        logfile = File.join(log_root, "#{name}.log")
+
+        Logger.new(:stdout => STDOUT, :color => color, :logdev => logfile,
+          :level => level, :progname => name)
+      end
+    end
+
+    def data
+      @data ||= @loader.read
+    end
+
+    def merge_driver_hash(driver_hash)
+      default_driver_hash.rmerge(common_driver_hash.rmerge(driver_hash))
+    end
+
+    def calculate_path(path, suite_name)
+      suite_path      = File.join(test_base_path, suite_name, path)
+      common_path     = File.join(test_base_path, path)
+      top_level_path  = File.join(Dir.pwd, path)
+
+      if File.directory?(suite_path)
+        suite_path
+      elsif File.directory?(common_path)
+        common_path
+      elsif File.directory?(top_level_path)
+        top_level_path
+      else
+        nil
+      end
+    end
+
+    def default_driver_hash
+      { :driver_plugin => DEFAULT_DRIVER_PLUGIN, :driver_config => {} }
+    end
+
+    def common_driver_hash
+      data.select do |key, value|
+        [:driver_plugin, :driver_config].include?(key)
+      end
+    end
+  end
+end

data/lib/kitchen/driver/base.rb

@@ -0,0 +1,180 @@
+# -*- 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.
+
+module Kitchen
+
+  module Driver
+
+    # Base class for a driver. A driver is responsible for carrying out the
+    # lifecycle activities of an instance, such as creating, converging, and
+    # destroying an instance.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Base
+
+      include ShellOut
+      include Logging
+
+      attr_writer :instance
+
+      class << self
+        attr_reader :serial_actions
+      end
+
+      def initialize(config = {})
+        @config = config
+        self.class.defaults.each do |attr, value|
+          @config[attr] = value unless @config[attr]
+        end
+        Array(self.class.validations).each do |tuple|
+          tuple.last.call(tuple.first, config[tuple.first])
+        end
+      end
+
+      # Provides hash-like access to configuration keys.
+      #
+      # @param attr [Object] configuration key
+      # @return [Object] value at configuration key
+      def [](attr)
+        config[attr]
+      end
+
+      # Creates an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def create(state) ; end
+
+      # Converges a running instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def converge(state) ; end
+
+      # Sets up an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def setup(state) ; end
+
+      # Verifies a converged instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def verify(state) ; end
+
+      # Destroys an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @raise [ActionFailed] if the action could not be completed
+      def destroy(state) ; end
+
+      # Returns the shell command array that will log into an instance.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @return [Array] an array of command line tokens to be used in a
+      #   fork/exec
+      # @raise [ActionFailed] if the action could not be completed
+      def login_command(state)
+        raise ActionFailed, "Remote login is not supported in this driver."
+      end
+
+      protected
+
+      attr_reader :config, :instance
+
+      ACTION_METHODS = %w{create converge setup verify destroy}.
+        map(&:to_sym).freeze
+
+      def logger
+        instance.logger
+      end
+
+      def puts(msg)
+        info(msg)
+      end
+
+      def print(msg)
+        info(msg)
+      end
+
+      def run_command(cmd, use_sudo = nil, log_subject = nil)
+        use_sudo = config[:use_sudo] if use_sudo.nil?
+        log_subject = Util.to_snake_case(self.class.to_s)
+
+        super(cmd, use_sudo, log_subject)
+      end
+
+      def kb_setup_cmd
+        busser.setup_cmd
+      end
+
+      def kb_sync_cmd
+        busser.sync_cmd
+      end
+
+      def kb_run_cmd
+        busser.run_cmd
+      end
+
+      def busser
+        @busser ||= begin
+          raise ClientError, "Instance must be set for Driver" if instance.nil?
+
+          Busser.new(instance.suite.name)
+        end
+      end
+
+      def self.defaults
+        @defaults ||= Hash.new
+      end
+
+      def self.default_config(attr, value)
+        defaults[attr] = value
+      end
+
+      def self.validations
+        @validations
+      end
+
+      def self.required_config(attr, &block)
+        @validations = [] if @validations.nil?
+        if ! block_given?
+          klass = self
+          block = lambda do |attr, value|
+            if value.nil? || value.to_s.empty?
+              raise UserError, "#{klass}#config[:#{attr}] cannot be blank"
+            end
+          end
+        end
+        @validations << [attr, block]
+      end
+
+      def self.no_parallel_for(*methods)
+        Array(methods).each do |meth|
+          if ! ACTION_METHODS.include?(meth)
+            raise ClientError, "##{meth} is not a valid no_parallel_for method"
+          end
+        end
+
+        @serial_actions ||= []
+        @serial_actions += methods
+      end
+    end
+  end
+end

data/lib/kitchen/driver/dummy.rb

@@ -0,0 +1,81 @@
+# -*- 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 'kitchen'
+
+module Kitchen
+
+  module Driver
+
+    # Dummy driver for Kitchen.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Dummy < Kitchen::Driver::Base
+
+      default_config :sleep, 0
+      default_config :random_failure, false
+
+      def create(state)
+        state[:my_id] = "#{instance.name}-#{Time.now.to_i}"
+        report(:create, state)
+      end
+
+      def converge(state)
+        report(:converge, state)
+      end
+
+      def setup(state)
+        report(:setup, state)
+      end
+
+      def verify(state)
+        report(:verify, state)
+      end
+
+      def destroy(state)
+        report(:destroy, state)
+        state.delete(:my_id)
+      end
+
+      private
+
+      def report(action, state)
+        what = action.capitalize
+        info("[Dummy] #{what} on instance=#{instance} with state=#{state}")
+        sleep_if_set
+        random_failure_if_set(action)
+        debug("[Dummy] #{what} completed (#{config[:sleep]}s).")
+      end
+
+      def sleep_if_set
+        sleep(config[:sleep].to_f) if config[:sleep].to_f > 0.0
+      end
+
+      def random_failure_if_set(action)
+        if config[:random_failure] && randomly_fail?
+          debug("[Dummy] Random failure for action ##{action}.")
+          raise ActionFailed, "Action ##{action} failed for #{instance.to_str}."
+        end
+      end
+
+      def randomly_fail?
+        [true, false].sample
+      end
+    end
+  end
+end