beaker 0.0.0

data/lib/beaker/test_config.rb

@@ -0,0 +1,148 @@
+require 'open-uri'
+require 'yaml'
+
+module Beaker
+  # Config was taken by Ruby.
+  class TestConfig
+
+    attr_accessor :logger
+    def initialize(config_file, options)
+      @options = options
+      @logger = options[:logger]
+      @config = load_file(config_file)
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    def ssh_defaults
+      {
+        :config                => false,
+        :paranoid              => false,
+        :timeout               => 300,
+        :auth_methods          => ["publickey"],
+        :keys                  => [@options[:keyfile]],
+        :port                  => 22,
+        :user_known_hosts_file => "#{ENV['HOME']}/.ssh/known_hosts",
+        :forward_agent         => true
+      }
+    end
+
+    def load_file(config_file)
+      if config_file.is_a? Hash
+        config = config_file
+      else
+        config = YAML.load_file(config_file)
+
+        # Make sure the roles array is present for all hosts
+        config['HOSTS'].each_key do |host|
+          config['HOSTS'][host]['roles'] ||= []
+        end
+      end
+
+      # Merge some useful date into the config hash
+      config['CONFIG'] ||= {}
+      consoleport = ENV['consoleport'] || config['CONFIG']['consoleport'] || 443
+      config['CONFIG']['consoleport']        = consoleport.to_i
+      config['CONFIG']['ssh']                = ssh_defaults.merge(config['CONFIG']['ssh'] || {})
+      config['CONFIG']['modules']            = @options[:modules] || []
+
+      if is_pe?
+        config['CONFIG']['pe_dir']           = puppet_enterprise_dir
+        config['CONFIG']['pe_ver']           = puppet_enterprise_version
+        config['CONFIG']['pe_ver_win']       = puppet_enterprise_version_win
+      else
+        config['CONFIG']['puppet_ver']       = @options[:puppet]
+        config['CONFIG']['facter_ver']       = @options[:facter]
+        config['CONFIG']['hiera_ver']        = @options[:hiera]
+        config['CONFIG']['hiera_puppet_ver'] = @options[:hiera_puppet]
+      end
+      # need to load expect versions of PE binaries
+      config
+    end
+
+    def is_pe?
+      @is_pe ||= @options[:type] =~ /pe/ ? true : false
+      unless ENV['IS_PE'].nil?
+        @is_pe ||= ENV['IS_PE'] == 'true'
+      end
+      @is_pe
+    end
+
+    def puppet_enterprise_dir
+      @pe_dir ||= ENV['pe_dist_dir'] || '/opt/enterprise/dists'
+    end
+
+    def load_pe_version
+      dist_dir = puppet_enterprise_dir
+      version_file = ENV['pe_version_file'] || 'LATEST'
+      version = ""
+      begin
+        open("#{dist_dir}/#{version_file}") do |file|
+          while line = file.gets
+            if /(\w.*)/ =~ line then
+              version = $1.strip
+              @logger.debug "Found LATEST: Puppet Enterprise Version #{version}"
+            end
+          end
+        end
+      rescue
+        version = 'unknown'
+      end
+      return version
+    end
+
+    def puppet_enterprise_version
+      @pe_ver ||= load_pe_version if is_pe?
+    end
+
+    def load_pe_version_win
+      dist_dir = puppet_enterprise_dir
+      version_file = ENV['pe_version_file'] || 'LATEST-win'
+      version = ""
+      begin
+        open("#{dist_dir}/#{version_file}") do |file|
+          while line = file.gets
+            if /(\w.*)/ =~ line then
+              version=$1.strip
+              @logger.debug "Found LATEST: Puppet Enterprise Windows Version #{version}"
+            end
+          end
+        end
+      rescue
+        version = 'unknown'
+      end
+      return version
+    end
+
+    def puppet_enterprise_version_win
+      @pe_ver_win ||= load_pe_version_win if is_pe?
+    end
+
+    # Print out test configuration
+    def dump
+      # Access "platform" for each host
+      @config["HOSTS"].each_key do|host|
+        @logger.notify "Platform for #{host} #{@config["HOSTS"][host]['platform']}"
+      end
+
+      # Access "roles" for each host
+      @config["HOSTS"].each_key do|host|
+        @config["HOSTS"][host]['roles'].each do |role|
+          @logger.notify "Role for #{host} #{role}"
+        end
+      end
+
+      # Print out Ruby versions
+      @config["HOSTS"].each_key do|host|
+          @logger.notify "Ruby version for #{host} #{@config["HOSTS"][host][:ruby_ver]}"
+      end
+
+      # Access @config keys/values
+      @config["CONFIG"].each_key do|cfg|
+          @logger.notify "Config Key|Val: #{cfg} #{@config["CONFIG"][cfg].inspect}"
+      end
+    end
+  end
+end

data/lib/beaker/test_suite.rb

@@ -0,0 +1,288 @@
+# -*- coding: utf-8 -*-
+require 'rexml/document'
+require 'fileutils'
+%w(test_case logger).each do |lib|
+  begin
+    require "beaker/#{lib}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), lib))
+  end
+end
+
+module Beaker
+  # This Class is in need of some cleaning up beyond what can be quickly done.
+  # Things to keep in mind:
+  #   * Global State Change
+  #   * File Creation Relative to CWD  -- Should be a config option
+  #   * Better Method Documentation
+  class TestSuite
+    attr_reader :name, :options, :config, :fail_mode
+
+    def initialize(name, hosts, options, config, fail_mode = nil)
+      @name      = name.gsub(/\s+/, '-')
+      @hosts     = hosts
+      @run       = false
+      @options   = options
+      @config    = config
+      @fail_mode = @options[:fail_mode] || fail_mode
+      @logger    = options[:logger]
+
+      @test_cases = []
+      @test_files = []
+
+      options[:tests].each do |root|
+        if File.file? root then
+          @test_files << root
+        else
+          @test_files += Dir.glob(
+            File.join(root, "**/*.rb")
+          ).select { |f| File.file?(f) }
+        end
+      end
+      report_and_raise(@logger, RuntimeError.new("#{@name}: no test files found..."), "TestSuite: initialize") if @test_files.empty?
+
+      @test_files = @test_files.sort
+    rescue => e
+      report_and_raise(@logger, e, "TestSuite: initialize")
+    end
+
+    def run
+      @run = true
+      @start_time = Time.now
+
+      configure_logging 
+
+      @test_files.each do |test_file|
+        @logger.notify
+        @logger.notify "Begin #{test_file}"
+        start = Time.now
+        test_case = TestCase.new(@hosts, @logger, config, options, test_file).run_test
+        duration = Time.now - start
+        @test_cases << test_case
+
+        state = test_case.test_status == :skip ? 'skipp' : test_case.test_status
+        msg = "#{test_file} #{state}ed in %.2f seconds" % duration.to_f
+        case test_case.test_status
+        when :pass
+          @logger.success msg
+        when :skip
+          @logger.debug msg
+        when :fail
+          @logger.error msg
+          break if fail_mode #all failure modes cause us to kick out early on failure
+        when :error
+          @logger.warn msg
+          break if fail_mode #all failure modes cause use to kick out early on error
+        end
+      end
+
+      # REVISIT: This changes global state, breaking logging in any future runs
+      # of the suite – or, at least, making them highly confusing for anyone who
+      # has not studied the implementation in detail. --daniel 2011-03-14
+      summarize
+      write_junit_xml if options[:xml]
+
+      # Allow chaining operations...
+      return self
+    end
+
+    def run_and_raise_on_failure
+      begin
+        run
+        return self if success?
+      rescue => e
+        #failed during run
+        report_and_raise(@logger, e, "TestSuite :run_and_raise_on_failure")
+      else
+        #failed during test
+        report_and_raise(@logger, RuntimeError.new("Failed while running the #{name} suite"), "TestSuite: report_and_raise_on_failure")
+      end
+    end
+
+    def fail_without_test_run
+      report_and_raise(@logger, RuntimeError.new("#{@name}: you have not run the tests yet"), "TestSuite: fail_without_test_run") unless @run
+    end
+
+    def success?
+      fail_without_test_run
+      sum_failed == 0
+    end
+
+    def failed?
+      !success?
+    end
+
+    def test_count
+      @test_count ||= @test_cases.length
+    end
+
+    def passed_tests
+      @passed_tests ||= @test_cases.select { |c| c.test_status == :pass }.length
+    end
+
+    def errored_tests
+      @errored_tests ||= @test_cases.select { |c| c.test_status == :error }.length
+    end
+
+    def failed_tests
+      @failed_tests ||= @test_cases.select { |c| c.test_status == :fail }.length
+    end
+
+    def skipped_tests
+      @skipped_tests ||= @test_cases.select { |c| c.test_status == :skip }.length
+    end
+
+    def pending_tests
+      @pending_tests ||= @test_cases.select {|c| c.test_status == :pending}.length
+    end
+
+    private
+
+    def sum_failed
+      @sum_failed ||= failed_tests + errored_tests
+    end
+
+    def write_junit_xml
+      # This should be a configuration option
+      File.directory?('junit') or FileUtils.mkdir('junit')
+
+      begin
+        doc   = REXML::Document.new
+        doc.add(REXML::XMLDecl.new(1.0))
+
+        suite = REXML::Element.new('testsuite', doc)
+        suite.add_attribute('name',     name)
+        suite.add_attribute('tests',    test_count)
+        suite.add_attribute('errors',   errored_tests)
+        suite.add_attribute('failures', failed_tests)
+        suite.add_attribute('skip',     skipped_tests)
+        suite.add_attribute('pending',  pending_tests)
+
+        @test_cases.each do |test|
+          item = REXML::Element.new('testcase', suite)
+          item.add_attribute('classname', File.dirname(test.path))
+          item.add_attribute('name',      File.basename(test.path))
+          item.add_attribute('time',      test.runtime)
+
+          # Did we fail?  If so, report that.
+          # We need to remove the escape character from colorized text, the
+          # substitution of other entities is handled well by Rexml
+          if test.test_status == :fail || test.test_status == :error then
+            status = REXML::Element.new('failure', item)
+            status.add_attribute('type', test.test_status.to_s)
+            if test.exception then
+              status.add_attribute('message', test.exception.to_s.gsub(/\e/, ''))
+              status.text = test.exception.backtrace.join("\n")
+            end
+          end
+
+          if test.stdout then
+            REXML::Element.new('system-out', item).text =
+              test.stdout.gsub(/\e/, '')
+          end
+
+          if test.stderr then
+            text = REXML::Element.new('system-err', item)
+            text.text = test.stderr.gsub(/\e/, '')
+          end
+        end
+
+        # junit/name.xml will be created in a directory relative to the CWD
+        # --  JLS 2/12
+        File.open("junit/#{name}.xml", 'w') { |fh| doc.write(fh) }
+      rescue Exception => e
+        @logger.error "failure in XML output:\n#{e.to_s}\n" + e.backtrace.join("\n")
+      end
+    end
+
+    def summarize
+      fail_without_test_run
+
+      summary_logger = Logger.new(log_path("#{name}-summary.txt"), STDOUT)
+
+      summary_logger.notify <<-HEREDOC
+    Test Suite: #{name} @ #{@start_time}
+
+    - Host Configuration Summary -
+      HEREDOC
+
+      config.dump
+
+      elapsed_time = @test_cases.inject(0.0) {|r, t| r + t.runtime.to_f }
+      average_test_time = elapsed_time / test_count
+
+      summary_logger.notify %Q[
+
+            - Test Case Summary for suite '#{name}' -
+     Total Suite Time: %.2f seconds
+    Average Test Time: %.2f seconds
+            Attempted: #{test_count}
+               Passed: #{passed_tests}
+               Failed: #{failed_tests}
+              Errored: #{errored_tests}
+              Skipped: #{skipped_tests}
+              Pending: #{pending_tests}
+
+    - Specific Test Case Status -
+      ] % [elapsed_time, average_test_time]
+
+      grouped_summary = @test_cases.group_by{|test_case| test_case.test_status }
+
+      summary_logger.notify "Failed Tests Cases:"
+      (grouped_summary[:fail] || []).each do |test_case|
+        print_test_failure(test_case)
+      end
+
+      summary_logger.notify "Errored Tests Cases:"
+      (grouped_summary[:error] || []).each do |test_case|
+        print_test_failure(test_case)
+      end
+
+      summary_logger.notify "Skipped Tests Cases:"
+      (grouped_summary[:skip] || []).each do |test_case|
+        print_test_failure(test_case)
+      end
+
+      summary_logger.notify "Pending Tests Cases:"
+      (grouped_summary[:pending] || []).each do |test_case|
+        print_test_failure(test_case)
+      end
+
+      summary_logger.notify("\n\n")
+    end
+
+    def print_test_failure(test_case)
+      test_reported = if test_case.exception
+                        "reported: #{test_case.exception.inspect}"
+                      else
+                        test_case.test_status
+                      end
+      @logger.notify "  Test Case #{test_case.path} #{test_reported}"
+    end
+
+    def log_path(name)
+      @@log_dir ||= File.join("log", @start_time.strftime("%F_%T"))
+      unless File.directory?(@@log_dir) then
+        FileUtils.mkdir_p(@@log_dir)
+        FileUtils.cp(options[:config],(File.join(@@log_dir,"config.yml")))
+
+        latest = File.join("log", "latest")
+        if !File.exist?(latest) or File.symlink?(latest) then
+          File.delete(latest) if File.exist?(latest)
+          File.symlink(File.basename(@@log_dir), latest)
+        end
+      end
+
+      File.join('log', 'latest', name)
+    end
+
+    # Setup log dir
+    def configure_logging
+      @logger.add_destination(log_path("#{@name}-run.log"))
+      #
+      # This is an awful hack to maintain backward compatibility until tests
+      # are ported to use logger.
+      Beaker.const_set(:Log, @logger) unless defined?( Log )
+    end
+  end
+end

data/lib/beaker/utils.rb

@@ -0,0 +1,7 @@
+[ 'ntp_control', 'setup_helper', 'repo_control', 'validator' ].each do |file|
+  begin
+    require "beaker/utils/#{file}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), 'utils', file))
+  end
+end

data/lib/beaker/utils/ntp_control.rb

@@ -0,0 +1,42 @@
+module Beaker
+  module Utils
+    class NTPControl
+      NTPSERVER = 'pool.ntp.org'
+      def initialize(options, hosts)
+        @options = options.dup
+        @hosts = hosts
+        @logger = options[:logger]
+      end
+
+      def timesync
+        @logger.notify "Update system time sync"
+        @logger.notify "run ntpdate against NTP pool systems"
+        @hosts.each do |host|
+          success=FALSE
+          if host['platform'].include? 'solaris-10'
+            host.exec(Command.new("sleep 10 && ntpdate -w #{NTPSERVER}"))
+          elsif host['platform'].include? 'windows'
+            # The exit code of 5 is for Windows 2008 systems where the w32tm /register command
+            # is not actually necessary.
+            host.exec(Command.new("w32tm /register"), :acceptable_exit_codes => [0,5])
+            host.exec(Command.new("net start w32time"), :acceptable_exit_codes => [0,2])
+            host.exec(Command.new("w32tm /config /manualpeerlist:#{NTPSERVER} /syncfromflags:manual /update"))
+            host.exec(Command.new("w32tm /resync"))
+          else
+            count=0
+            until success do
+              count+=1
+              raise "ntp time sync failed after #{count} tries" and break if count > 3
+              if host.exec(Command.new("ntpdate -t 20 #{NTPSERVER}")).exit_code == 0 
+                success=TRUE 
+              end
+            end
+            @logger.notify "NTP date succeeded after #{count} tries"
+          end
+        end
+      rescue => e
+        report_and_raise(@logger, e, "timesync (--ntp)")
+      end
+    end
+  end
+end