test-kitchen 1.0.0.alpha.0 → 1.0.0.alpha.1

data/lib/kitchen/driver.rb

@@ -26,11 +26,13 @@ module Kitchen
     # @return [Driver::Base] a driver instance
     # @raise [ClientError] if a driver instance could not be created
     def self.for_plugin(plugin, config)
-      require "kitchen/driver/#{plugin}"
+      first_load = require("kitchen/driver/#{plugin}")
 
       str_const = Util.to_camel_case(plugin)
       klass = self.const_get(str_const)
-      klass.new(config)
+      object = klass.new(config)
+      object.verify_dependencies if first_load
+      object
     rescue UserError
       raise
     rescue LoadError

data/lib/kitchen/driver/base.rb

@@ -20,6 +20,20 @@ module Kitchen
 
   module Driver
 
+    # Value object to track a shell command that will be passed to Kernel.exec
+    # for execution.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class LoginCommand
+
+      attr_reader :cmd_array, :options
+
+      def initialize(cmd_array, options = {})
+        @cmd_array = cmd_array
+        @options = options
+      end
+    end
+
     # 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.
@@ -84,16 +98,25 @@ module Kitchen
       # @raise [ActionFailed] if the action could not be completed
       def destroy(state) ; end
 
-      # Returns the shell command array that will log into an instance.
+      # Returns the shell command 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
+      # @return [LoginCommand] an object containing the array of command line
+      #   tokens and exec options 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
 
+      # Performs whatever tests that may be required to ensure that this driver
+      # will be able to function in the current environment. This may involve
+      # checking for the presence of certain directories, software installed,
+      # etc.
+      #
+      # @raise [UserError] if the driver will not be able to perform or if a
+      #   documented dependency is missing from the system
+      def verify_dependencies ; end
+
       protected
 
       attr_reader :config, :instance
@@ -102,7 +125,7 @@ module Kitchen
         map(&:to_sym).freeze
 
       def logger
-        instance.logger
+        instance ? instance.logger : Kitchen.logger
       end
 
       def puts(msg)
@@ -113,11 +136,12 @@ module Kitchen
         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)
+      def run_command(cmd, options = {})
+        base_options = {
+          :use_sudo => config[:use_sudo],
+          :log_subject => Util.to_snake_case(self.class.to_s)
+        }.merge(options)
+        super(cmd, base_options)
       end
 
       def kb_setup_cmd

data/lib/kitchen/driver/ssh_base.rb

@@ -71,7 +71,7 @@ module Kitchen
         args += %W{ -i #{config[:ssh_key]}} if config[:ssh_key]
         args += %W{ #{config[:username]}@#{state[:hostname]}}
 
-        ["ssh", *args]
+        Driver::LoginCommand.new(["ssh", *args])
       end
 
       protected
@@ -91,9 +91,9 @@ module Kitchen
       end
 
       def install_omnibus(ssh_args)
-        flag = config[:require_chef_omnibus].downcase
+        flag = config[:require_chef_omnibus]
         version = if flag.is_a?(String) && flag != "latest"
-          "-s -- -v #{flag}"
+          "-s -- -v #{flag.downcase}"
         else
           ""
         end

data/lib/kitchen/generator/init.rb

@@ -0,0 +1,196 @@
+# -*- 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 'thor/group'
+
+module Kitchen
+
+  module Generator
+
+    # A project initialization generator, to help prepare a cookbook project
+    # for testing with Kitchen.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class Init < Thor::Group
+
+      include Thor::Actions
+
+      class_option :driver, :type => :array, :aliases => "-D",
+        :default => "kitchen-vagrant",
+        :desc => <<-D.gsub(/^\s+/, '').gsub(/\n/, ' ')
+          One or more Kitchen Driver gems to be installed or added to a
+          Gemfile
+        D
+
+      class_option :create_gemfile, :type => :boolean, :default => false,
+        :desc => <<-D.gsub(/^\s+/, '').gsub(/\n/, ' ')
+          Whether or not to create a Gemfile if one does not exist.
+          Default: false
+        D
+
+      def init
+        create_file ".kitchen.yml", default_yaml
+
+        rakedoc = <<-RAKE.gsub(/^ {10}/, '')
+
+          begin
+            require 'kitchen/rake_tasks'
+            Kitchen::RakeTasks.new
+          rescue LoadError
+            puts ">>>>> Kitchen gem not loaded, omitting tasks" unless ENV['CI']
+          end
+        RAKE
+        append_to_file("Rakefile", rakedoc) if init_rakefile?
+
+        thordoc = <<-THOR.gsub(/^ {10}/, '')
+
+          begin
+            require 'kitchen/thor_tasks'
+            Kitchen::ThorTasks.new
+          rescue LoadError
+            puts ">>>>> Kitchen gem not loaded, omitting tasks" unless ENV['CI']
+          end
+        THOR
+        append_to_file("Thorfile", thordoc) if init_thorfile?
+
+        empty_directory "test/integration/default" if init_test_dir?
+        append_to_gitignore(".kitchen/")
+        append_to_gitignore(".kitchen.local.yml")
+        prepare_gemfile if File.exists?("Gemfile") || options[:create_gemfile]
+        add_drivers
+
+        if @display_bundle_msg
+          say "You must run `bundle install' to fetch any new gems.", :red
+        end
+      end
+
+      private
+
+      def default_yaml
+        cookbook_name = if File.exists?(File.expand_path('metadata.rb'))
+          MetadataChopper.extract('metadata.rb').first
+        else
+          nil
+        end
+        run_list = cookbook_name ? "recipe[#{cookbook_name}]" : nil
+        driver_plugin = Array(options[:driver]).first || 'dummy'
+
+        { 'driver_plugin' => driver_plugin.sub(/^kitchen-/, ''),
+          'platforms' => platforms_hash,
+          'suites' => [
+            { 'name' => 'default',
+              'run_list' => Array(run_list),
+              'attributes' => Hash.new
+            },
+          ]
+        }.to_yaml
+      end
+
+      def platforms_hash
+        url_base = "https://opscode-vm.s3.amazonaws.com/vagrant/boxes"
+        platforms = [
+          { :n => 'ubuntu', :vers => %w(12.04 10.04), :rl => "recipe[apt]" },
+          { :n => 'centos', :vers => %w(6.3 5.8), :rl => "recipe[yum::epel]" },
+        ]
+        platforms = platforms.map do |p|
+          p[:vers].map do |v|
+            { 'name' => "#{p[:n]}-#{v}",
+              'driver_config' => {
+                'box' => "opscode-#{p[:n]}-#{v}",
+                'box_url' => "#{url_base}/opscode-#{p[:n]}-#{v}.box"
+              },
+              'run_list' => Array(p[:rl])
+            }
+          end
+        end.flatten
+      end
+
+      def init_rakefile?
+        File.exists?("Rakefile") &&
+          not_in_file?("Rakefile", %r{require 'kitchen/rake_tasks'})
+      end
+
+      def init_thorfile?
+        File.exists?("Thorfile") &&
+          not_in_file?("Thorfile", %r{require 'kitchen/thor_tasks'})
+      end
+
+      def init_test_dir?
+        Dir.glob("test/integration/*").select { |d| File.directory?(d) }.empty?
+      end
+
+      def append_to_gitignore(line)
+        create_file(".gitignore") unless File.exists?(".gitignore")
+
+        if IO.readlines(".gitignore").grep(%r{^#{line}}).empty?
+          append_to_file(".gitignore", "#{line}\n")
+        end
+      end
+
+      def prepare_gemfile
+        create_gemfile_if_missing
+        add_gem_to_gemfile
+      end
+
+      def create_gemfile_if_missing
+        unless File.exists?("Gemfile")
+          create_file("Gemfile", %{source 'https://rubygems.org'\n\n})
+        end
+      end
+
+      def add_gem_to_gemfile
+        if not_in_file?("Gemfile", %r{gem 'test-kitchen'})
+          append_to_file("Gemfile",
+            %{gem 'test-kitchen', :group => :integration\n})
+          @display_bundle_msg = true
+        end
+      end
+
+      def add_drivers
+        return if options[:driver].nil? || options[:driver].empty?
+        display_warning = false
+
+        Array(options[:driver]).each do |driver_gem|
+          if File.exists?("Gemfile") || options[:create_gemfile]
+            add_driver_to_gemfile(driver_gem)
+          else
+            install_gem(driver_gem)
+          end
+        end
+      end
+
+      def add_driver_to_gemfile(driver_gem)
+        if not_in_file?("Gemfile", %r{gem '#{driver_gem}'})
+          append_to_file("Gemfile",
+            %{gem '#{driver_gem}', :group => :integration\n})
+          @display_bundle_msg = true
+        end
+      end
+
+      def install_gem(driver_gem)
+        Bundler.with_clean_env do
+          run "gem install #{driver_gem}"
+        end
+      end
+
+      def not_in_file?(filename, regexp)
+        IO.readlines(filename).grep(regexp).empty?
+      end
+    end
+  end
+end

data/lib/kitchen/generator/new_plugin.rb

@@ -0,0 +1,190 @@
+# -*- 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 'thor/group'
+
+module Kitchen
+
+  module Generator
+
+    # A generator to create a new Kitchen Driver gem project.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class NewPlugin < Thor::Group
+
+      include Thor::Actions
+
+      argument :plugin_name
+
+      class_option :license, :aliases => "-l", :default => "apachev2",
+        :desc => "License type for gem (apachev2, mit, gplv3, gplv2, reserved)"
+
+      def new_plugin
+        if ! run("command -v bundle", :verbose => false)
+          die "Bundler must be installed and on your PATH: `gem install bundler'"
+        end
+
+        @plugin_name = plugin_name
+        @gem_name = "kitchen-#{plugin_name}"
+        @gemspec = "#{gem_name}.gemspec"
+        @klass_name = Util.to_camel_case(plugin_name)
+        @constant = Util.to_snake_case(plugin_name).upcase
+        @license = options[:license]
+        @author = %x{git config user.name}.chomp
+        @email = %x{git config user.email}.chomp
+        @year = Time.now.year
+
+        create_plugin
+      end
+
+      private
+
+      attr_reader :plugin_name, :gem_name, :gemspec, :klass_name,
+        :constant, :license, :author, :email, :year
+
+      def create_plugin
+        run("bundle gem #{gem_name}") unless File.directory?(gem_name)
+
+        inside(gem_name) do
+          update_gemspec
+          update_gemfile
+          update_rakefile
+          create_src_files
+          cleanup
+          create_license
+          add_git_files
+        end
+      end
+
+      def update_gemspec
+        gsub_file(gemspec, %r{require '#{gem_name}/version'},
+          %{require 'kitchen/driver/#{plugin_name}_version.rb'})
+        gsub_file(gemspec, %r{Kitchen::#{klass_name}::VERSION},
+          %{Kitchen::Driver::#{constant}_VERSION})
+        gsub_file(gemspec, %r{(gem\.executables\s*) =.*$},
+          '\1 = []')
+        gsub_file(gemspec, %r{(gem\.description\s*) =.*$},
+          '\1 = "' + "Kitchen::Driver::#{klass_name} - " +
+            "A Kitchen Driver for #{klass_name}\"")
+        gsub_file(gemspec, %r{(gem\.summary\s*) =.*$},
+          '\1 = gem.description')
+        gsub_file(gemspec, %r{(gem\.homepage\s*) =.*$},
+          '\1 = "https://github.com/opscode/' +
+            "#{gem_name}/\"")
+        insert_into_file(gemspec,
+          "\n  gem.add_dependency 'test-kitchen'\n", :before => "end\n")
+        insert_into_file(gemspec,
+          "\n  gem.add_development_dependency 'cane'\n", :before => "end\n")
+        insert_into_file(gemspec,
+          "  gem.add_development_dependency 'tailor'\n", :before => "end\n")
+      end
+
+      def update_gemfile
+        append_to_file("Gemfile", "\ngroup :test do\n  gem 'rake'\nend\n")
+      end
+
+      def update_rakefile
+        append_to_file("Rakefile", <<-RAKEFILE.gsub(/^ {10}/, ''))
+          require 'cane/rake_task'
+          require 'tailor/rake_task'
+
+          desc "Run cane to check quality metrics"
+          Cane::RakeTask.new
+
+          Tailor::RakeTask.new
+
+          task :default => [ :cane, :tailor ]
+        RAKEFILE
+      end
+
+      def create_src_files
+        license_comments = rendered_license.gsub(/^/, '# ').gsub(/\s+$/, '')
+
+        empty_directory("lib/kitchen/driver")
+        create_template("plugin/version.rb",
+          "lib/kitchen/driver/#{plugin_name}_version.rb",
+          :klass_name => klass_name, :constant => constant,
+          :license => license_comments)
+        create_template("plugin/driver.rb",
+          "lib/kitchen/driver/#{plugin_name}.rb",
+          :klass_name => klass_name, :license => license_comments,
+          :author => author, :email => email)
+      end
+
+      def rendered_license
+        TemplateRenderer.render("plugin/license_#{license}",
+          :author => author, :email => email, :year => year)
+      end
+
+      def create_license
+        dest_file = case license
+        when "mit" then "LICENSE.txt"
+        when "apachev2", "reserved" then "LICENSE"
+        when "gplv2", "gplv3" then "COPYING"
+        else
+          raise ArgumentError, "No such license #{license}"
+        end
+
+        create_file(dest_file, rendered_license)
+      end
+
+      def cleanup
+        %W(LICENSE.txt lib/#{gem_name}/version.rb lib/#{gem_name}.rb).each do |f|
+          run("git rm -f #{f}") if File.exists?(f)
+        end
+        remove_dir("lib/#{gem_name}")
+      end
+
+      def add_git_files
+        run("git add .")
+      end
+
+      def create_template(template, destination, data = {})
+        create_file(destination, TemplateRenderer.render(template, data))
+      end
+
+      # Renders an ERB template with a hash of template variables.
+      #
+      # @author Fletcher Nichol <fnichol@nichol.ca>
+      class TemplateRenderer < OpenStruct
+
+        def self.render(template, data = {})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.render
+        end
+
+        def initialize(template, data = {})
+          super()
+          data[:template] = template
+          data.each { |key, value| send("#{key}=", value) }
+        end
+
+        def render
+          ERB.new(IO.read(template_file)).result(binding)
+        end
+
+        private
+
+        def template_file
+          Kitchen.source_root.join("templates", "#{template}.erb").to_s
+        end
+      end
+    end
+  end
+end