test-kitchen 1.0.0.beta.4 → 1.0.0.rc.1

data/lib/kitchen/cli.rb

@@ -43,7 +43,7 @@ module Kitchen
       Kitchen.logger = Kitchen.default_file_logger
       @config = Kitchen::Config.new(
         :loader     => Kitchen::Loader::YAML.new(ENV['KITCHEN_YAML']),
-        :log_level  => ENV['KITCHEN_LOG'] && ENV['KITCHEN_LOG'].downcase.to_sym
+        :log_level  => ENV.fetch('KITCHEN_LOG', "info").downcase.to_sym
       )
     end
 
@@ -52,7 +52,10 @@ module Kitchen
       :desc => "List the name of each instance only, one per line"
     method_option :debug, :aliases => "-d", :type => :boolean,
       :desc => "Show computed driver configuration for each instance"
+    method_option :log_level, :aliases => "-l",
+      :desc => "Set the log level (debug, info, warn, error, fatal)"
     def list(*args)
+      update_config!
       result = parse_subcommand(args.first)
       if options[:debug]
         Array(result).each { |i| debug_instance(i) }
@@ -327,7 +330,7 @@ module Kitchen
       [
         color_pad(instance.name),
         color_pad(instance.driver.name),
-        color_pad(format_provisioner(instance.driver[:provisioner])),
+        color_pad(instance.provisioner.name),
         format_last_action(instance.last_action)
       ]
     end
@@ -335,15 +338,17 @@ module Kitchen
     def debug_instance(instance)
       say "--------"
       say "Instance: #{instance.name}"
-      say "Driver: #{instance.driver.name}"
-      say "Driver Config:"
+      say "Driver (#{instance.driver.name}):"
       instance.driver.config_keys.sort.each do |key|
-        say "    #{key}: #{instance.driver[key]}"
+        say "    #{key}: #{instance.driver[key].inspect}"
       end
-      if instance.kind_of?(Instance::Cheflike)
-        say "Chef Config:"
-        say "    attributes: #{instance.attributes.inspect}"
-        say "    run_list: #{instance.run_list.inspect}"
+      say "Provisioner (#{instance.provisioner.name}):"
+      instance.provisioner.config_keys.sort.each do |key|
+        say "    #{key}: #{instance.provisioner[key].inspect}"
+      end
+      say "Busser (#{instance.busser.name}):"
+      instance.busser.config_keys.sort.each do |key|
+        say "    #{key}: #{instance.busser[key].inspect}"
       end
       say ""
     end
@@ -363,10 +368,6 @@ module Kitchen
       end
     end
 
-    def format_provisioner(name)
-      name.split('_').map { |word| word.capitalize }.join(' ')
-    end
-
     def update_config!
       if options[:log_level]
         level = options[:log_level].downcase.to_sym

data/lib/kitchen/config.rb

@@ -16,8 +16,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'vendor/hash_recursive_merge'
-
 module Kitchen
 
   # Base configuration class for Kitchen. This class exposes configuration such
@@ -26,193 +24,136 @@ module Kitchen
   # @author Fletcher Nichol <fnichol@nichol.ca>
   class Config
 
-    attr_accessor :kitchen_root
-    attr_accessor :test_base_path
+    attr_reader :kitchen_root
+    attr_reader :log_root
+    attr_reader :test_base_path
+    attr_reader :loader
     attr_accessor :log_level
-    attr_writer :platforms
-    attr_writer :suites
-
-    # Default driver plugin to use
-    DEFAULT_DRIVER_PLUGIN = "dummy".freeze
-
-    # Default provisioner to use
-    DEFAULT_PROVISIONER = "chef_solo".freeze
 
     # Creates a new configuration.
     #
     # @param [Hash] options configuration
     # @option options [#read] :loader
     # @option options [String] :kitchen_root
+    # @option options [String] :log_root
     # @option options [String] :test_base_path
     # @option options [Symbol] :log_level
     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
+      @loader         = options.fetch(:loader) { Kitchen::Loader::YAML.new }
+      @kitchen_root   = options.fetch(:kitchen_root) { Dir.pwd }
+      @log_level      = options.fetch(:log_level) { Kitchen::DEFAULT_LOG_LEVEL }
+      @log_root       = options.fetch(:log_root) { default_log_root }
+      @test_base_path = options.fetch(:test_base_path) { default_test_base_path }
+    end
+
+    # @return [Array<Instance>] all instances, resulting from all platform and
+    #   suite combinations
+    def instances
+      @instances ||= Collection.new(build_instances)
     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) })
+        data.platform_data.map { |pdata| Platform.new(pdata) })
     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
+        data.suite_data.map { |sdata| Suite.new(sdata) })
     end
 
     private
 
-    def new_suite(hash)
-      path_hash = {
-        :data_bags_path => calculate_path("data_bags", hash[:name], hash[:data_bags_path]),
-        :roles_path     => calculate_path("roles", hash[:name], hash[:roles_path]),
-        :nodes_path     => calculate_path("nodes", hash[:name], hash[:nodes_path]),
-      }
-
-      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
-      hash[:driver_config][:provisioner] = hash[:provisioner]
-
-      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)
+      filter_instances.map.with_index do |(suite, platform), index|
+        new_instance(suite, platform, index)
       end
-      Collection.new(results)
-    end
-
-    def new_instance(suite, platform, index)
-      platform_hash = platform_driver_hash(platform.name)
-      platform_hash[:driver_config].rmerge!(suite.driver_config)
-      driver = new_driver(merge_driver_hash(platform_hash))
-      provisioner = driver[:provisioner]
-
-      instance = Instance.new(
-        :suite    => extend_suite(suite, provisioner),
-        :platform => extend_platform(platform, provisioner),
-        :driver   => driver,
-        :logger   => new_instance_logger(index)
-      )
-      extend_instance(instance, provisioner)
     end
 
-    def extend_suite(suite, provisioner)
-      case provisioner.to_s.downcase
-      when /^chef_/ then suite.dup.extend(Suite::Cheflike)
-      when /^puppet_/ then suite.dup.extend(Suite::Puppetlike)
-      else suite.dup
-      end
+    def data
+      @data ||= DataMunger.new(loader.read, kitchen_config)
     end
 
-    def extend_platform(platform, provisioner)
-      case provisioner.to_s.downcase
-      when /^chef_/ then platform.dup.extend(Platform::Cheflike)
-      else platform.dup
-      end
+    def default_log_root
+      File.join(kitchen_root, Kitchen::DEFAULT_LOG_DIR)
     end
 
-    def extend_instance(instance, provisioner)
-      case provisioner.to_s.downcase
-      when /^chef_/ then instance.extend(Instance::Cheflike)
-      when /^puppet_/ then instance.extend(Instance::Puppetlike)
-      else instance
+    def default_test_base_path
+      File.join(kitchen_root, Kitchen::DEFAULT_TEST_DIR)
+    end
+
+    def filter_instances
+      suites.product(platforms).select do |suite, platform|
+        if !suite.includes.empty?
+          suite.includes.include?(platform.name)
+        elsif !suite.excludes.empty?
+          !suite.excludes.include?(platform.name)
+        else
+          true
+        end
       end
     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[:driver_config] ||= {}
-
-      h.select do |key, value|
-        [:driver_plugin, :driver_config, :provisioner].include?(key)
-      end
+    def instance_name(suite, platform)
+      Instance.name_for(suite, platform)
     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
+    def kitchen_config
+      @kitchen_config ||= {
+        :defaults => {
+          :driver       => Driver::DEFAULT_PLUGIN,
+          :provisioner  => Provisioner::DEFAULT_PLUGIN
+        },
+        :kitchen_root   => kitchen_root,
+        :test_base_path => test_base_path,
+        :log_level      => log_level,
+      }
     end
 
-    def data
-      @data ||= @loader.read
+    def new_busser(suite, platform)
+      bdata = data.busser_data_for(suite.name, platform.name)
+      Busser.new(suite.name, bdata)
     end
 
-    def merge_driver_hash(driver_hash)
-      default_driver_hash.rmerge(common_driver_hash.rmerge(driver_hash))
+    def new_driver(suite, platform)
+      ddata = data.driver_data_for(suite.name, platform.name)
+      Driver.for_plugin(ddata[:name], ddata)
     end
 
-    def calculate_path(path, suite_name, local_path)
-      custom_path     = File.join(kitchen_root, local_path) if local_path
-      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 custom_path and File.directory?(custom_path)
-        custom_path
-      elsif 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
+    def new_instance(suite, platform, index)
+      Instance.new(
+        :busser       => new_busser(suite, platform),
+        :driver       => new_driver(suite, platform),
+        :logger       => new_logger(suite, platform, index),
+        :suite        => suite,
+        :platform     => platform,
+        :provisioner  => new_provisioner(suite, platform),
+        :state_file   => new_state_file(suite, platform)
+      )
     end
 
-    def default_driver_hash
-      {
-        :driver_plugin  => DEFAULT_DRIVER_PLUGIN,
-        :driver_config  => {},
-        :provisioner    => DEFAULT_PROVISIONER
-      }
+    def new_logger(suite, platform, index)
+      name = instance_name(suite, platform)
+      Logger.new(
+        :stdout   => STDOUT,
+        :color    => Color::COLORS[index % Color::COLORS.size].to_sym,
+        :logdev   => File.join(log_root, "#{name}.log"),
+        :level    => Util.to_logger_level(self.log_level),
+        :progname => name
+      )
     end
 
-    def common_driver_hash
-      data.select do |key, value|
-        [:driver_plugin, :driver_config, :provisioner].include?(key)
-      end
+    def new_provisioner(suite, platform)
+      pdata = data.provisioner_data_for(suite.name, platform.name)
+      Provisioner.for_plugin(pdata[:name], pdata)
     end
 
-    def default_test_base_path
-      File.join(kitchen_root, 'test/integration')
+    def new_state_file(suite, platform)
+      StateFile.new(kitchen_root, instance_name(suite, platform))
     end
   end
 end

data/lib/kitchen/data_munger.rb

@@ -0,0 +1,224 @@
+# -*- 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 'vendor/hash_recursive_merge'
+
+module Kitchen
+
+  # Class to handle recursive merging of configuration between platforms,
+  # suites, and common data.
+  #
+  # This object will mutate the data Hash passed into its constructor and so
+  # should not be reused or shared across threads.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class DataMunger
+
+    def initialize(data, kitchen_config = {})
+      @data = data
+      @kitchen_config = kitchen_config
+      convert_legacy_driver_format!
+      convert_legacy_chef_paths_format!
+      convert_legacy_require_chef_omnibus_format!
+      move_chef_data_to_provisioner!
+    end
+
+    def busser_data_for(suite, platform)
+      merged_data_for(:busser, suite, platform, :version).tap do |bdata|
+        set_kitchen_config_at!(bdata, :kitchen_root)
+        set_kitchen_config_at!(bdata, :test_base_path)
+        set_kitchen_config_at!(bdata, :log_level)
+      end
+    end
+
+    def driver_data_for(suite, platform)
+      merged_data_for(:driver, suite, platform).tap do |ddata|
+        set_kitchen_config_at!(ddata, :kitchen_root)
+        set_kitchen_config_at!(ddata, :test_base_path)
+        set_kitchen_config_at!(ddata, :log_level)
+      end
+    end
+
+    def platform_data
+      data.fetch(:platforms, [])
+    end
+
+    def provisioner_data_for(suite, platform)
+      merged_data_for(:provisioner, suite, platform).tap do |pdata|
+        set_kitchen_config_at!(pdata, :kitchen_root)
+        set_kitchen_config_at!(pdata, :test_base_path)
+        set_kitchen_config_at!(pdata, :log_level)
+        combine_arrays!(pdata, :run_list, :platform, :suite)
+      end
+    end
+
+    def suite_data
+      data.fetch(:suites, [])
+    end
+
+    private
+
+    attr_reader :data, :kitchen_config
+
+    def combine_arrays!(root, key, *namespaces)
+      if root.has_key?(key)
+        root[key] = namespaces.
+          map { |namespace| root.fetch(key).fetch(namespace, []) }.flatten.
+          compact
+      end
+    end
+
+    def convert_legacy_chef_paths_format!
+      data.fetch(:suites, []).each do |suite|
+        %w{data data_bags environments nodes roles}.each do |key|
+          move_chef_data_to_provisioner_at!(suite, "#{key}_path".to_sym)
+        end
+      end
+    end
+
+    def convert_legacy_driver_format!
+      convert_legacy_driver_format_at!(data)
+      data.fetch(:platforms, []).each do |platform|
+        convert_legacy_driver_format_at!(platform)
+      end
+      data.fetch(:suites, []).each do |suite|
+        convert_legacy_driver_format_at!(suite)
+      end
+    end
+
+    def convert_legacy_driver_format_at!(root)
+      if root.has_key?(:driver_config)
+        ddata = root.fetch(:driver, Hash.new)
+        ddata = { :name => ddata } if ddata.is_a?(String)
+        root[:driver] = root.delete(:driver_config).rmerge(ddata)
+      end
+
+      if root.has_key?(:driver_plugin)
+        ddata = root.fetch(:driver, Hash.new)
+        ddata = { :name => ddata } if ddata.is_a?(String)
+        root[:driver] = { :name => root.delete(:driver_plugin) }.rmerge(ddata)
+      end
+    end
+
+    def convert_legacy_require_chef_omnibus_format!
+      convert_legacy_require_chef_omnibus_format_at!(data)
+      data.fetch(:platforms, []).each do |platform|
+        convert_legacy_require_chef_omnibus_format_at!(platform)
+      end
+      data.fetch(:suites, []).each do |suite|
+        convert_legacy_require_chef_omnibus_format_at!(suite)
+      end
+    end
+
+    def convert_legacy_require_chef_omnibus_format_at!(root)
+      key = :require_chef_omnibus
+      ddata = root.fetch(:driver, Hash.new)
+
+      if ddata.is_a?(Hash) && ddata.has_key?(key)
+        pdata = root.fetch(:provisioner, Hash.new)
+        pdata = { :name => pdata } if pdata.is_a?(String)
+        root[:provisioner] =
+          { key => root.fetch(:driver).delete(key) }.rmerge(pdata)
+      end
+    end
+
+    def merged_data_for(key, suite, platform, default_key = :name)
+      ddata = normalized_default_data(key, default_key)
+      cdata = normalized_common_data(key, default_key)
+      pdata = normalized_platform_data(key, default_key, platform)
+      sdata = normalized_suite_data(key, default_key, suite)
+
+      ddata.rmerge(cdata.rmerge(pdata.rmerge(sdata)))
+    end
+
+    def move_chef_data_to_provisioner!
+      data.fetch(:suites, []).each do |suite|
+        move_chef_data_to_provisioner_at!(suite, :attributes)
+        move_chef_data_to_provisioner_at!(suite, :run_list)
+      end
+
+      data.fetch(:platforms, []).each do |platform|
+        move_chef_data_to_provisioner_at!(platform, :attributes)
+        move_chef_data_to_provisioner_at!(platform, :run_list)
+      end
+    end
+
+    def move_chef_data_to_provisioner_at!(root, key)
+      if root.has_key?(key)
+        pdata = root.fetch(:provisioner, Hash.new)
+        pdata = { :name => pdata } if pdata.is_a?(String)
+        if ! root.fetch(key, nil).nil?
+          root[:provisioner] = pdata.rmerge({ key => root.delete(key) })
+        end
+      end
+    end
+
+    def namespace_array!(root, key, bucket)
+      root[key] = { bucket => root.fetch(key) } if root.has_key?(key)
+    end
+
+    def normalized_common_data(key, default_key)
+      cdata = data.fetch(key, Hash.new)
+      cdata = cdata.nil? ? Hash.new : cdata.dup
+      cdata = { default_key => cdata } if cdata.is_a?(String)
+      cdata
+    end
+
+    def normalized_default_data(key, default_key)
+      ddata = kitchen_config.fetch(:defaults, Hash.new).fetch(key, Hash.new).dup
+      ddata = { default_key => ddata } if ddata.is_a?(String)
+      ddata
+    end
+
+    def normalized_platform_data(key, default_key, platform)
+      pdata = platform_data_for(platform).fetch(key, Hash.new)
+      pdata = pdata.nil? ? Hash.new : pdata.dup
+      pdata = { default_key => pdata } if pdata.is_a?(String)
+      namespace_array!(pdata, :run_list, :platform)
+      pdata
+    end
+
+    def normalized_suite_data(key, default_key, suite)
+      sdata = suite_data_for(suite).fetch(key, Hash.new)
+      sdata = sdata.nil? ? Hash.new : sdata.dup
+      sdata = { default_key => sdata } if sdata.is_a?(String)
+      namespace_array!(sdata, :run_list, :suite)
+      sdata
+    end
+
+    def platform_data_for(name)
+      data.fetch(:platforms, Hash.new).find(lambda { Hash.new }) do |platform|
+        platform.fetch(:name, nil) == name
+      end
+    end
+
+    def set_kitchen_config_at!(root, key)
+      kdata = data.fetch(:kitchen, Hash.new)
+
+      root.delete(key) if root.has_key?(key)
+      root[key] = kitchen_config.fetch(key) if kitchen_config.has_key?(key)
+      root[key] = kdata.fetch(key) if kdata.has_key?(key)
+    end
+
+    def suite_data_for(name)
+      data.fetch(:suites, Hash.new).find(lambda { Hash.new }) do |suite|
+        suite.fetch(:name, nil) == name
+      end
+    end
+  end
+end