test-kitchen 0.7.0 → 1.0.0.alpha.0

data/lib/test-kitchen/cli.rb

@@ -1,282 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# 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 'test-kitchen/environment'
-require 'test-kitchen/ui'
-require 'mixlib/cli'
-
-module TestKitchen
-  module CLI
-    class Kitchen
-      include Mixlib::CLI
-
-      option :platform,
-        :long  => "--platform PLATFORM",
-        :description => "The platform to use. If not specified tests will be run against all platforms.",
-        :default => nil
-
-      option :configuration,
-        :long  => "--configuration CONFIG",
-        :description => "The project configuration to test. Defaults to all configurations."
-
-      option :runner,
-        :short => "-r RUNNER",
-        :long => "--runner RUNNER",
-        :description => "The underlying virtualization platform to test with."
-
-      option :teardown,
-        :boolean => true,
-        :default => false,
-        :long => "--teardown",
-        :description => "Teardown test nodes between runs."
-
-      option :help,
-        :short => "-h",
-        :long => "--help",
-        :description => "Show this message",
-        :on => :tail,
-        :boolean => true,
-        :show_options => true,
-        :exit => 0
-
-      option :version,
-        :short => "-v",
-        :long => "--version",
-        :description => "Show Test Kitchen version",
-        :boolean => true,
-        :proc => lambda {|v| puts "test-kitchen: #{::TestKitchen::VERSION}"},
-        :exit => 0
-
-      attr_accessor :runner
-      attr_accessor :env
-      attr_accessor :ui
-
-      def command_help?
-        ARGV.last == '--help'
-      end
-
-      def scaffolding?
-        ARGV == ['init']
-      end
-
-      def run
-        validate_and_parse_options
-        quiet_traps
-        Kitchen.run(ARGV, options)
-        exit 0
-      end
-
-      def initialize(argv=[])
-        $stdout.sync = true
-        $stderr.sync = true
-        super()
-        parse_options(argv)
-        @ui = TestKitchen::UI.new(STDOUT, STDERR, STDIN, {})
-
-        # TODO: Move this out of the constructor
-        load_environment unless command_help? || scaffolding?
-      end
-
-      def load_environment
-        @env = TestKitchen::Environment.new(:ui => @ui).tap{|e| e.load!}
-      end
-
-      def runner
-        @runner ||= begin
-          # CLI option takes precedence, then project
-          runner_name = config[:runner] || env.project.runner || env.default_runner
-          runner_class = TestKitchen::Runner.targets[runner_name]
-          runner = runner_class.new(env, config)
-        end
-      end
-
-      # Class Methods
-
-      def self.run(argv, options={})
-        load_commands
-        subcommand_class = Kitchen.subcommand_class_from(argv)
-        subcommand_class.options = options.merge!(subcommand_class.options)
-
-        instance = subcommand_class.new(ARGV)
-        instance.run
-      end
-
-      def self.load_commands
-        @commands_loaded ||= begin
-          if subcommand_files = Dir[File.join(TestKitchen.source_root, 'lib', 'test-kitchen', 'cli', '*.rb')]
-            subcommand_files.each { |subcommand| Kernel.load subcommand.to_s }
-          end
-          true
-        end
-      end
-
-      NO_COMMAND_GIVEN = "You need to pass a sub-command (e.g., kitchen SUB-COMMAND)\n"
-
-      # BEGIN CARGO CULT FROM Chef::Knife
-      def self.inherited(subclass)
-        unless subclass.unnamed?
-          subcommands[subclass.snake_case_name] = subclass
-        end
-      end
-
-      def self.subcommands
-        @@subcommands ||= {}
-      end
-
-      def self.subcommand_category
-        @category || snake_case_name.split('_').first unless unnamed?
-      end
-
-      def self.snake_case_name
-        convert_to_snake_case(name.split('::').last) unless unnamed?
-      end
-
-      def self.convert_to_snake_case(str, namespace=nil)
-        str = str.dup
-        str.sub!(/^#{namespace}(\:\:)?/, '') if namespace
-        str.gsub!(/[A-Z]/) {|s| "_" + s}
-        str.downcase!
-        str.sub!(/^\_/, "")
-        str
-      end
-
-      # Does this class have a name? (Classes created via Class.new don't)
-      def self.unnamed?
-        name.nil? || name.empty?
-      end
-
-      def self.subcommands_by_category
-        unless @subcommands_by_category
-          @subcommands_by_category = Hash.new { |hash, key| hash[key] = [] }
-          subcommands.each do |snake_cased, klass|
-            @subcommands_by_category[klass.subcommand_category] << snake_cased
-          end
-        end
-        @subcommands_by_category
-      end
-
-      # Print the list of subcommands knife knows about. If +preferred_category+
-      # is given, only subcommands in that category are shown
-      def self.list_commands(preferred_category=nil)
-        load_commands
-
-        category_desc = preferred_category ? preferred_category + " " : ''
-        $stdout.puts "Available #{category_desc}subcommands: (for details, kitchen SUB-COMMAND --help)\n\n"
-
-        if preferred_category && subcommands_by_category.key?(preferred_category)
-          commands_to_show = {preferred_category => subcommands_by_category[preferred_category]}
-        else
-          commands_to_show = subcommands_by_category
-        end
-
-        commands_to_show.sort.each do |category, commands|
-          next if category =~ /deprecated/i
-          $stdout.puts "** #{category.upcase} COMMANDS **"
-          commands.each do |command|
-            $stdout.puts subcommands[command].banner if subcommands[command]
-          end
-          $stdout.puts
-        end
-      end
-
-      def self.subcommand_class_from(args)
-        command_words = args.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
-
-        subcommand_class = nil
-
-        while ( !subcommand_class ) && ( !command_words.empty? )
-          snake_case_class_name = command_words.join("_")
-          unless subcommand_class = subcommands[snake_case_class_name]
-            command_words.pop
-          end
-        end
-        # see if we got the command as e.g., knife node-list
-        subcommand_class ||= subcommands[args.first.gsub('-', '_')]
-        subcommand_class || subcommand_not_found!(args)
-      end
-
-      # :nodoc:
-      # Error out and print usage. probably becuase the arguments given by the
-      # user could not be resolved to a subcommand.
-      def self.subcommand_not_found!(args)
-        $stderr.puts "Cannot find sub command for: '#{args.join(' ')}'"
-        list_commands
-        exit 10
-      end
-      # END CARGO CULT FROM Chef::Knife
-
-      private
-
-      # BEGIN CARGO CULT FROM Chef::Application::Knife
-      def quiet_traps
-        trap("TERM") do
-          exit 1
-        end
-
-        trap("INT") do
-          exit 2
-        end
-      end
-
-      def validate_and_parse_options
-        # Checking ARGV validity *before* parse_options because parse_options
-        # mangles ARGV in some situations
-        if no_command_given?
-          print_help_and_exit(1, NO_COMMAND_GIVEN)
-        elsif no_subcommand_given?
-          if (want_help? || want_version?)
-            print_help_and_exit
-          else
-            print_help_and_exit(2, NO_COMMAND_GIVEN)
-          end
-        end
-      end
-
-      def no_subcommand_given?
-        ARGV[0] =~ /^-/
-      end
-
-      def no_command_given?
-        ARGV.empty?
-      end
-
-      def want_help?
-        ARGV[0] =~ /^(--help|-h)$/
-      end
-
-      def want_version?
-        ARGV[0] =~ /^(--version|-v)$/
-      end
-
-      def print_help_and_exit(exitcode=1, fatal_message=nil)
-        $stderr.puts(fatal_message) if fatal_message
-
-        begin
-          self.parse_options
-        rescue OptionParser::InvalidOption => e
-            puts "#{e}\n"
-        end
-        puts self.opt_parser
-        puts
-        TestKitchen::CLI::Kitchen.list_commands
-        exit exitcode
-      end
-      # END CARGO CULT FROM Chef::Application::Knife
-    end
-  end
-end

data/lib/test-kitchen/dsl.rb

@@ -1,63 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# 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 'hashr'
-require 'test-kitchen/project'
-require 'test-kitchen/platform'
-require 'test-kitchen/runner/openstack/dsl'
-
-module TestKitchen
-  module DSL
-
-    module BasicDSL
-      def integration_test(name, &block)
-        env.project = Project::Ruby.new(name.to_s, &block)
-      end
-
-      def platform(name, &block)
-        env.platforms[name.to_s] = Platform.new(name, &block)
-      end
-
-      def default_runner(name)
-        env.default_runner = name
-      end
-    end
-    module CookbookDSL
-      def cookbook(name, &block)
-        env.project = Project::Cookbook.new(name.to_s, &block)
-      end
-    end
-
-    class File
-      include BasicDSL
-      include CookbookDSL
-
-      attr_reader :env
-
-      def load(path, env)
-        @env = env
-        begin
-          self.instance_eval(::File.read(path))
-        rescue SyntaxError
-          env.ui.info('Your Kitchenfile could not be loaded. Please check it for errors.', :red)
-          raise
-        end
-      end
-    end
-
-  end
-end

data/lib/test-kitchen/environment.rb

@@ -1,166 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# 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 'fileutils'
-require 'hashr'
-require 'pathname'
-require 'yajl'
-
-module TestKitchen
-
-  class Environment
-
-    attr_reader :root_path
-    attr_reader :tmp_path
-    attr_reader :cache_path
-    attr_reader :config
-    attr_reader :ui
-    attr_reader :kitchenfile_name
-    attr_accessor :project
-    attr_accessor :default_runner
-
-    KITCHEN_SUBDIRS = [".", "kitchen", "test/kitchen"]
-
-    def initialize(options={})
-
-      options[:kitchenfile_name] ||= []
-      options[:kitchenfile_name] = [options[:kitchenfile_name]] if !options[:kitchenfile_name].is_a?(Array)
-      options[:kitchenfile_name] += ["Kitchenfile", "kitchenfile"]
-      @kitchenfile_name = options[:kitchenfile_name]
-
-      if options[:ignore_kitchenfile] || ! root_path
-        @root_path = Pathname.new(Dir.pwd) + 'test' + 'kitchen'
-        @project = Project::Cookbook.new(File.basename(Dir.pwd))
-      end
-
-      @default_runner = "vagrant"
-      @tmp_path = root_path.join('.kitchen')
-      @cache_path = tmp_path.join('.cache')
-      @ui = options[:ui]
-
-      setup_tmp_path
-    end
-
-    # Inspired by Vagrant::Environment.root_path...danke Mitchell!
-    #
-    # The root path is the path where the top-most (loaded last)
-    # Vagrantfile resides. It can be considered the project root for
-    # this environment.
-    #
-    # @return [String]
-    def root_path
-      return @root_path if defined?(@root_path)
-
-      KITCHEN_SUBDIRS.each do |dir|
-        path = Pathname.new(Dir.pwd).join(dir)
-        found = kitchenfile_name.find do |rootfile|
-          path.join(rootfile).exist?
-        end
-        @root_path = path if found
-      end
-
-      @root_path
-    end
-
-    def platforms
-      @platforms ||= {}
-    end
-
-    def all_platforms
-      Hash[*platforms.values.map do |p|
-        p.versions.map{|key,value| ["#{p.name}-#{key}", value]}
-      end.flatten]
-    end
-
-    def platform_names
-      all_platforms.keys
-    end
-
-    def create_tmp_file(file_name, contents)
-      File.open(tmp_path.join(file_name), 'w') do |f|
-        f.write(contents)
-      end
-    end
-
-    def cookbook_paths
-      @cookbook_paths ||= begin
-        p = [tmp_path.join('cookbooks').to_s]
-        p << root_path.join('cookbooks').to_s if root_path.join('cookbooks').exist?
-        p
-      end
-    end
-
-    def setup_tmp_path
-      # pre-create required dirs
-      [ tmp_path, cache_path ].each do |dir|
-        FileUtils.mkdir_p(dir)
-      end
-    end
-
-    #---------------------------------------------------------------
-    # Load Methods
-    #---------------------------------------------------------------
-
-    # Returns a boolean representing if the environment has been
-    # loaded or not.
-    #
-    # @return [Bool]
-    def loaded?
-      !!@loaded
-    end
-
-    def load!
-      if !loaded?
-        @loaded = true
-        load_kitchenfiles
-      end
-
-      self
-    end
-
-    private
-
-    # Inspired by Vagrant::Environment.find_vagrantfile...danke Mitchell!
-    #
-    # Finds the Kitchenfile in the given directory.
-    #
-    # @param [Pathname] path Path to search in.
-    # @return [Pathname]
-    def find_kitchenfile(search_path)
-      @kitchenfile_name.each do |kitchenfile|
-        current_path = search_path.join(kitchenfile)
-        return current_path if current_path.exist?
-      end
-
-      nil
-    end
-
-    def load_kitchenfiles
-      # load Kitchenfile that ships with gem...seeds defaults
-      kitchenfiles = [File.expand_path("config/Kitchenfile", TestKitchen.source_root)]
-      # Load the user's Kitchenfile
-      kitchenfiles << find_kitchenfile(root_path) if root_path
-
-      kitchenfiles.flatten.compact.each do |kitchenfile|
-        dsl_file = DSL::File.new
-        dsl_file.load(kitchenfile, self)
-      end
-    end
-
-  end
-end

data/lib/test-kitchen/platform.rb

@@ -1,79 +0,0 @@
-#
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# 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 'hashr'
-require 'chef/mixin/params_validate'
-
-module TestKitchen
-  class Platform
-    include Chef::Mixin::ParamsValidate
-
-    attr_reader :name, :versions
-
-    def initialize(name, &block)
-      raise ArgumentError, "Platform name must be specified" if name.nil? || name.empty?
-
-      @name = name
-      @versions = {}
-      instance_eval(&block) if block_given?
-    end
-
-    def version(name, &block)
-      versions[name.to_s] = Version.new(name, &block)
-    end
-
-    class Version
-      include Chef::Mixin::ParamsValidate
-
-      attr_reader :name
-
-      # Virtual Box Specific Attributes
-      attr_writer :box, :box_url
-
-      def initialize(name, &block)
-        raise ArgumentError, "Version name must be specified" if name.nil? || name.empty?
-        @name = name
-        instance_eval(&block) if block_given?
-      end
-
-      OPENSTACK_OPTIONS = {
-        :image_id => nil, :flavor_id => nil, :install_chef => false,
-        :install_chef_cmd =>  "curl -L http://www.opscode.com/chef/install.sh | sudo bash",
-        :keyname => nil, :instance_name => nil, :ssh_user => "root", :ssh_key => nil}
-
-      OPENSTACK_OPTIONS.each do |option, default|
-        attr_writer option
-        define_method(option) do |*args|
-          arg = args.first
-          set_or_return(option, arg, default.nil? ? {} : {:default => default})
-        end
-      end
-
-
-      def box(arg=nil)
-        set_or_return(:box, arg, {})
-      end
-
-      def box_url(arg=nil)
-        set_or_return(:box_url, arg, {})
-      end
-
-    end
-
-  end
-end