beaker 0.0.0

data/lib/beaker/cli.rb

@@ -0,0 +1,113 @@
+module Beaker
+  class CLI
+    def initialize
+      @options = Beaker::Options.parse_args
+      @logger = Beaker::Logger.new(@options)
+      @options[:logger] = @logger
+
+      if not @options[:config] 
+        report_and_raise(@logger, RuntimeError.new("Argh!  There is no default for Config, specify one (-c or --config)!"), "CLI: initialize") 
+      end
+
+      @logger.debug("Options")
+      @options.each do |opt, val|
+        if val and val != [] 
+          @logger.debug("\t#{opt.to_s}:")
+          if val.kind_of?(Array)
+            val.each do |v|
+              @logger.debug("\t\t#{v.to_s}")
+            end
+          else
+            @logger.debug("\t\t#{val.to_s}")
+          end
+        end
+      end
+
+      @config = Beaker::TestConfig.new(@options[:config], @options)
+
+      #add additional paths to the LOAD_PATH
+      if not @options[:load_path].empty?
+        @options[:load_path].each do |path|
+          $LOAD_PATH << File.expand_path(path)
+        end
+      end
+      @options[:helper].each do |helper|
+        require File.expand_path(helper)
+      end
+
+      @hosts =  []
+      @network_manager = Beaker::NetworkManager.new(@config, @options, @logger)
+      @hosts = @network_manager.provision
+      #validate that the hosts are correctly configured
+      Beaker::Utils::Validator.validate(@hosts, @logger)
+
+    end
+
+    def execute!
+      @ntp_controller = Beaker::Utils::NTPControl.new(@options, @hosts)
+      @setup = Beaker::Utils::SetupHelper.new(@options, @hosts)
+      @repo_controller = Beaker::Utils::RepoControl.new(@options, @hosts)
+
+      setup_steps = [[:timesync, "Sync time on hosts", Proc.new {@ntp_controller.timesync}],
+                     [:root_keys, "Sync keys to hosts" , Proc.new {@setup.sync_root_keys}],
+                     [:repo_proxy, "Proxy packaging repositories on ubuntu, debian and solaris-11", Proc.new {@repo_controller.proxy_config}],
+                     [:add_el_extras, "Add Extra Packages for Enterprise Linux (EPEL) repository to el-* hosts", Proc.new {@repo_controller.add_el_extras}],
+                     [:add_master_entry, "Update /etc/hosts on master with master's ip", Proc.new {@setup.add_master_entry}]]
+      
+      begin
+        trap(:INT) do
+          @logger.warn "Interrupt received; exiting..."
+          exit(1)
+        end
+        #setup phase
+        setup_steps.each do |step| 
+          if (not @options.has_key?(step[0])) or @options[step[0]]
+            @logger.notify ""
+            @logger.notify "Setup: #{step[1]}"
+            step[2].call
+          end
+        end
+
+        #pre acceptance  phase
+        run_suite('pre-suite', @options.merge({:tests => @options[:pre_suite]}), :fail_fast)
+        #testing phase
+        begin
+          run_suite('acceptance', @options)
+        #post acceptance phase
+        rescue => e
+          #post acceptance on failure
+          #if we error then run the post suite as long as we aren't in fail-stop mode
+          run_suite('post-suite', @options.merge({:tests => @options[:post_suite]})) unless @options[:fail_mode] == "stop"
+          raise e
+        else
+          #post acceptance on success
+          run_suite('post-suite', @options.merge({:tests => @options[:post_suite]}))
+        end
+      #cleanup phase
+      rescue => e
+        #cleanup on error
+        #only do cleanup if we aren't in fail-stop mode
+        @logger.notify "Cleanup: cleaning up after failed run"
+        if @options[:fail_mode] != "stop"
+          @network_manager.cleanup
+        end
+        raise "Failed to execute tests!"
+      else
+        #cleanup on success
+        @logger.notify "Cleanup: cleaning up after successful run"
+        @network_manager.cleanup
+      end
+    end
+
+    def run_suite(name, options, failure_strategy = false)
+      if (options[:tests].empty?)
+        @logger.notify("No tests to run for suite '#{name}'")
+        return
+      end
+      Beaker::TestSuite.new(
+        name, @hosts, options, @config, failure_strategy
+      ).run_and_raise_on_failure
+    end
+
+  end
+end

data/lib/beaker/command.rb

@@ -0,0 +1,241 @@
+module Beaker
+  # An object that represents a "command" on a remote host. Is responsible
+  # for munging the environment correctly. Probably poorly named.
+  #
+  # @api public
+  class Command
+
+    DEFAULT_GIT_RUBYLIB = {
+      :default => [],
+      :host => %w(hieralibdir hierapuppetlibdir
+                  pluginlibpath puppetlibdir
+                  facterlibdir),
+      :opts => { :additive => true,
+                 :separator => {:host => 'pathseparator' }
+      }
+    }
+
+    DEFAULT_GIT_PATH = {
+      :default => [],
+      :host => %w(puppetbindir facterbindir hierabindir),
+      :opts => { :additive => true, :separator => ':' }
+    }
+
+    DEFAULT_GIT_ENV = { :PATH => DEFAULT_GIT_PATH, :RUBYLIB => DEFAULT_GIT_RUBYLIB }
+
+    # A string representing the (possibly) incomplete command
+    attr_accessor :command
+
+    # A hash key-values where the keys are environment variables to be set
+    attr_accessor :environment
+
+    # A hash of options. Keys with values of nil are considered flags
+    attr_accessor :options
+
+    # An array of additional arguments to be supplied to the command
+    attr_accessor :args
+
+    # @param [String] command The program to call, either an absolute path
+    #                         or one in the PATH (can be overridden)
+    # @param [Array]  args    These are addition arguments to the command
+    # @param [Hash]   options These are addition options to the command. They
+    #                         will be added in "--key=value" after the command
+    #                         but before the arguments. There is a special key,
+    #                         'ENV', that won't be used as a command option,
+    #                         but instead can be used to set any default
+    #                         environment variables
+    #
+    # @example Recommended usage programmatically:
+    #     Command.new('git add', files, :patch => true, 'ENV' => {'PATH' => '/opt/csw/bin'})
+    #
+    # @example My favorite example of a signature that we must maintain
+    #     Command.new('puppet', :resource, 'scheduled_task', name,
+    #                 [ 'ensure=present',
+    #                   'command=c:\\\\windows\\\\system32\\\\notepad2.exe',
+    #                   "arguments=args-#{name}" ] )
+    #
+    # @note For backwards compatability we must support any number of strings
+    #       or symbols (or arrays of strings an symbols) and essentially
+    #       ensure they are in a flattened array, coerced to strings, and
+    #       call #join(' ') on it.  We have options for the command line
+    #       invocation that must be turned into '--key=value' and similarly
+    #       joined as well as a hash of environment key value pairs, and
+    #       finally we need a hash of options to control the default envs that
+    #       are included.
+    def initialize command, args = [], options = {}
+      @command = command
+      @options = options
+      @args    = args
+      @environment = {}
+
+      # this is deprecated and will not allow you to use a command line
+      # option of `--environment`, please use ENV instead.
+      [:ENV, :environment, 'environment', 'ENV'].each do |k|
+         if @options[k].is_a?(Hash)
+           @environment = @environment.merge(@options.delete(k))
+         end
+      end
+
+    end
+
+    # @param [Host]   host An object that implements {Beaker::Host}'s
+    #                      interface.
+    # @param [String] cmd  An command to call.
+    # @param [Hash]   env  An optional hash of environment variables to be used
+    #
+    # @return [String] This returns the fully formed command line invocation.
+    def cmd_line host, cmd = @command, env = @environment
+      env_string = env.nil? ? '' : environment_string_for( host, env )
+
+      # This will cause things like `puppet -t -v agent` which is maybe bad.
+      "#{env_string} #{cmd} #{options_string} #{args_string}"
+    end
+
+    # @param [Hash] options These are the options that the command takes
+    #
+    # @return [String] String of the options and flags for command.
+    #
+    # @note Why no. Not the least bit Unixy, why do you ask?
+    def options_string opts = @options
+      flags = []
+      options = opts.dup
+      options.each_key do |key|
+        if options[key] == nil
+          flags << key
+          options.delete(key)
+        end
+      end
+
+      short_flags, long_flags = flags.partition {|flag| flag.to_s.length == 1 }
+      parsed_short_flags = short_flags.map {|f| "-#{f}" }
+      parsed_long_flags = long_flags.map {|f| "--#{f}" }
+
+      short_opts, long_opts = {}, {}
+      options.each_key do |key|
+        if key.to_s.length == 1
+          short_opts[key] = options[key]
+        else
+          long_opts[key] = options[key]
+        end
+      end
+      parsed_short_opts = short_opts.map {|k,v| "-#{k}=#{v}" }
+      parsed_long_opts = long_opts.map {|k,v| "--#{k}=#{v}" }
+
+      return (parsed_short_flags +
+              parsed_long_flags +
+              parsed_short_opts + parsed_long_opts).join(' ')
+    end
+
+    # @param [Array] args An array of arguments to the command.
+    #
+    # @return [String] String of the arguments for command.
+    def args_string args = @args
+      args.flatten.compact.join(' ')
+    end
+
+    # Determine the appropriate env commands for the given host.
+    #
+    # @param [Host]                 host  A Host object
+    # @param [Hash{String=>String}] env   An optional Hash containing
+    #                                     key-value pairs to be treated
+    #                                     as environment variables that
+    #                                     should be set for the duration
+    #                                     of the puppet command.
+    #
+    # @return [String] Returns a string containing command line arguments that
+    #                  will ensure the environment is correctly set for the
+    #                  given host.
+    #
+    # @note I dislike the principle of this method. There is host specific
+    #       knowledge contained here. Really the relationship should be
+    #       reversed where a host is asked for an appropriate Command when
+    #       given a generic Command.
+    def environment_string_for host, env 
+      return '' if env.empty?
+
+      env_array = parse_env_hash_for( host, env ).compact
+
+      # cygwin-ism
+      cmd = host['platform'] =~ /windows/ ? 'cmd.exe /c' : nil
+      env_array << cmd if cmd
+
+      environment_string = env_array.join(' ')
+
+      "env #{environment_string}"
+    end
+
+    # @!visibility private
+    def parse_env_hash_for( host, env = @environment )
+      # I needlessly love inject
+      env.inject([]) do |array_of_parsed_vars, key_and_value|
+        variable, val_in_unknown_format = *key_and_value
+        if val_in_unknown_format.is_a?(Hash)
+          value = val_in_unknown_format
+        elsif val_in_unknown_format.is_a?(Array)
+          value = { :default => val_in_unknown_format }
+        else
+          value = { :default => [ val_in_unknown_format.to_s ] }
+        end
+
+        var_settings = ensure_correct_structure_for( value )
+        # any default array of variable values ( like [ '/bin', '/usr/bin' ] for PATH )
+        default_values = var_settings[:default]
+
+        # host specific values, ie :host => [ 'puppetlibdir' ] is evaluated to
+        # an array with whatever host['puppetlibdir'] is
+        host_values = var_settings[:host].map { |attr| host[attr] }
+
+        # the two arrays are combined with host specific values first
+        var_array = ( host_values + default_values ).compact
+
+        # This will add the name of the variable, so :PATH => { ... }
+        # gets '${PATH}' appended to it if the :additive opt is passed
+        var_array << "${#{variable}}" if var_settings[:opts][:additive]
+
+        # This is stupid, but because we're using cygwin we sometimes need to use
+        # ':' and sometimes ';' on windows as a separator
+        attr_string = join_env_vars_for( var_array, host, var_settings[:opts][:separator] )
+        var_string = attr_string.empty? ? nil : %Q[#{variable}="#{attr_string}"]
+
+        # Now we append this to our accumulator array ie [ 'RUBYLIB=....', 'PATH=....' ]
+        array_of_parsed_vars << var_string
+
+        array_of_parsed_vars
+      end
+    end
+
+    # @!visibility private
+    def ensure_correct_structure_for( settings )
+      structure = { :default => [],
+        :host => [],
+        :opts => {}
+      }.merge( settings )
+      structure[:opts][:separator] ||= ':'
+      structure
+    end
+
+    # @!visibility private
+    def join_env_vars_for( array_of_variables, host, separator = ':' )
+      if separator.is_a?( Hash )
+        separator = host[separator[:host]]
+      end
+      array_of_variables.join( separator )
+    end
+  end
+
+  class PuppetCommand < Command
+    def initialize *args
+      command = "puppet #{args.shift}"
+      opts = args.last.is_a?(Hash) ? args.pop : Hash.new
+      opts['ENV'] ||= Hash.new
+      opts['ENV'] = opts['ENV'].merge( DEFAULT_GIT_ENV )
+      super( command, args, opts )
+    end
+  end
+
+  class HostCommand < Command
+    def cmd_line host
+      eval "\"#{@command}\""
+    end
+  end
+end

data/lib/beaker/command_factory.rb

@@ -0,0 +1,21 @@
+require 'test/unit/assertions'
+
+module Beaker
+  module CommandFactory
+    include Test::Unit::Assertions
+
+    def execute(command, options={}, &block)
+      result = self.exec(Command.new(command), options)
+
+      if block_given?
+        yield result
+      else
+        result.stdout.chomp
+      end
+    end
+
+    def fail_test(msg)
+      assert(false, msg)
+    end
+  end
+end

data/lib/beaker/dsl.rb

@@ -0,0 +1,85 @@
+[ 'install_utils', 'roles', 'outcomes', 'assertions',
+  'structure', 'helpers', 'wrappers' ].each do |file|
+  begin
+    require "beaker/dsl/#{file}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), 'dsl', file))
+  end
+end
+
+module Beaker
+  # This is a catch all module for including Puppetlabs home grown testing
+  # DSL. This module is mixed into {Beaker::TestCase} and can be
+  # mixed into any test runner by defining the methods that it requires to
+  # interact with. If not all of the functionality is required sub modules of
+  # the DSL may be mixed into a test runner of your choice.
+  #
+  # Currently most DSL modules require #logger and #hosts defined. #logger
+  # should provided the methods #debug, #warn and #notify and may be a
+  # wrapper to any logger you wish (or {Beaker::Logger}). #hosts
+  # should return an array of objects which conform to the interface defined
+  # in {Beaker::Host} (primarily it should provide Hash like access
+  # and interfaces like {Beaker::Host#exec},
+  # {Beaker::Host#do_scp_to}, and
+  # {Beaker::Host#do_scp_from}.
+  #
+  #
+  # @example Writing a complete testcase to be ran by the builtin test runner.
+  #     test_name 'Ensure My App Starts Correctly' do
+  #       confine :except, :platform => ['windows', 'solaris']
+  #
+  #       teardown do
+  #         on master, puppet('resource mything ensure=absent')
+  #         on agents, 'kill -9 allTheThings'
+  #       end
+  #
+  #       step 'Ensure Pre-Requisites are Installed' do
+  #       end
+  #
+  #       with_puppet_running_on master, :master, :logdest => '/tmp/blah' do
+  #
+  #         step 'Run Startup Script' do
+  #         end
+  #
+  #         step 'And... Did it work?' do
+  #         end
+  #       end
+  #     end
+  #
+  # @example Writing an Example to be ran within RSpec
+  #     #=> spec_helper.rb
+  #       RSpec.configure do |c|
+  #         c.include 'beaker/dsl/helpers'
+  #         c.include 'beaker/dsl/rspec/matchers'
+  #         c.include 'beaker/dsl/rspec/expectations'
+  #         c.include 'beaker/host'
+  #       end
+  #
+  #     #=> my_acceptance_spec.rb
+  #     require 'spec_helper'
+  #
+  #     describe 'A Test With RSpec' do
+  #       let(:hosts)  { Host.new('blah', 'blah', 'not helpful' }
+  #       let(:logger) { Where.is('the', 'rspec', 'logger')     }
+  #
+  #       after do
+  #         on master, puppet('resource mything ensure=absent')
+  #         on agents, 'kill -9 allTheThings'
+  #       end
+  #
+  #       it 'tests stuff?' do
+  #         result = on( hosts.first, 'ls ~' )
+  #         expect( result.stdout ).to match /my_file/
+  #       end
+  #     end
+  #
+  module DSL
+    include Beaker::DSL::Roles
+    include Beaker::DSL::Outcomes
+    include Beaker::DSL::Structure
+    include Beaker::DSL::Assertions
+    include Beaker::DSL::Wrappers
+    include Beaker::DSL::Helpers
+    include Beaker::DSL::InstallUtils
+  end
+end