beaker 1.16.0 → 1.17.0

data/lib/beaker/options/presets.rb

@@ -4,50 +4,84 @@ module Beaker
     #into the Beaker options Object.
     module Presets
 
+      # This is a constant that describes the variables we want to collect
+      # from the environment. The keys correspond to the keys in
+      # `self.presets` (flattened) The values are an optional array of
+      # environment variable names to look for. The array structure allows
+      # us to define multiple environment variables for the same
+      # configuration value. They are checked in the order they are arrayed
+      # so that preferred and "fallback" values work as expected.
+      ENVIRONMENT_SPEC = {
+        :home                 => 'HOME',
+        :project              => ['BEAKER_PROJECT', 'BEAKER_project'],
+        :department           => ['BEAKER_DEPARTMENT', 'BEAKER_department'],
+        :jenkins_build_url    => ['BEAKER_BUILD_URL', 'BUILD_URL'],
+        :consoleport          => ['BEAKER_CONSOLEPORT', 'consoleport'],
+        :is_pe                => ['BEAKER_IS_PE', 'IS_PE'],
+        :pe_dir               => ['BEAKER_PE_DIR', 'pe_dist_dir'],
+        :pe_version_file      => ['BEAKER_PE_VERSION_FILE', 'pe_version_file'],
+        :pe_ver               => ['BEAKER_PE_VER', 'pe_ver'],
+        :forge_host           => ['BEAKER_FORGE_HOST', 'forge_host'],
+        :package_proxy        => ['BEAKER_PACKAGE_PROXY'],
+        :release_apt_repo_url => ['BEAKER_RELEASE_APT_REPO', 'RELEASE_APT_REPO'],
+        :release_yum_repo_url => ['BEAKER_RELEASE_YUM_REPO', 'RELEASE_YUM_REPO'],
+        :dev_builds_url       => ['BEAKER_DEV_BUILDS_URL', 'DEV_BUILDS_URL'],
+        :q_puppet_enterpriseconsole_auth_user_email => 'q_puppet_enterpriseconsole_auth_user_email',
+        :q_puppet_enterpriseconsole_auth_password   => 'q_puppet_enterpriseconsole_auth_password',
+        :q_puppet_enterpriseconsole_smtp_host       => 'q_puppet_enterpriseconsole_smtp_host',
+        :q_puppet_enterpriseconsole_smtp_port       => 'q_puppet_enterpriseconsole_smtp_port',
+        :q_puppet_enterpriseconsole_smtp_username   => 'q_puppet_enterpriseconsole_smtp_username',
+        :q_puppet_enterpriseconsole_smtp_password   => 'q_puppet_enterpriseconsole_smtp_password',
+        :q_puppet_enterpriseconsole_smtp_use_tls    => 'q_puppet_enterpriseconsole_smtp_use_tls',
+        :q_verify_packages                          => 'q_verify_packages',
+        :q_puppetdb_password                        => 'q_puppetdb_password',
+      }
+
+      # Takes an environment_spec and searches the processes environment variables accordingly
+      #
+      # @param [Hash{Symbol=>Array,String}] env_var_spec  the spec of what env vars to search for
+      #
+      # @return [Hash] Found environment values
+      def self.collect_env_vars( env_var_spec )
+        env_var_spec.inject({:answers => {}}) do |memo, key_value|
+          key, value = key_value[0], key_value[1]
+
+          set_env_var = Array(value).detect {|possible_variable| ENV[possible_variable] }
+          memo[key] = ENV[set_env_var] if set_env_var
+
+          memo
+        end
+      end
+
+      # Takes a hash where the values are found environment configuration values
+      # and munges them to appropriate Beaker configuration values
+      #
+      # @param [Hash{Symbol=>String}] found_env_vars  Environment variables to munge
+      #
+      # @return [Hash] Environment config values munged appropriately
+      def self.munge_found_env_vars( found_env_vars )
+        found_env_vars[:answers] ||= {}
+        found_env_vars.each_pair do |key,value|
+          found_env_vars[:answers][key] = value if key.to_s =~ /q_/
+        end
+        found_env_vars[:consoleport] &&= found_env_vars[:consoleport].to_i
+        found_env_vars[:type] = found_env_vars[:is_pe] == 'true' || found_env_vars[:is_pe] == 'yes' ? 'pe' : nil
+        found_env_vars[:pe_version_file_win] = found_env_vars[:pe_version_file]
+        found_env_vars[:answers].delete_if {|key, value| value.nil? or value.empty? }
+        found_env_vars.delete_if {|key, value| value.nil? or value.empty? }
+      end
+
+
       # Generates an OptionsHash of the environment variables of interest to Beaker
       #
       # @return [OptionsHash] The supported environment variables in an OptionsHash,
       #                       empty or nil environment variables are removed from the OptionsHash
       def self.env_vars
         h = Beaker::Options::OptionsHash.new
-        consoleport = ENV['BEAKER_CONSOLEPORT'] || ENV['consoleport']
-        h.merge({
-          :home                => ENV['HOME'],
-          :project             => ENV['BEAKER_PROJECT'] || ENV['BEAKER_project'],
-          :department          => ENV['BEAKER_DEPARTMENT'] || ENV['BEAKER_department'],
-          :jenkins_build_url   => ENV['BEAKER_BUILD_URL'] || ENV['BUILD_URL'],
-          :release_apt_repo_url=> ENV['BEAKER_RELEASE_APT_REPO'] || ENV['RELEASE_APT_REPO'] || "http://apt.puppetlabs.com",
-          :release_yum_repo_url=> ENV['BEAKER_RELEASE_YUM_REPO'] || ENV['RELEASE_YUM_REPO'] || "http://yum.puppetlabs.com",
-          :dev_builds_url      => ENV['BEAKER_DEV_BUILDS_URL'] || ENV['DEV_BUILDS_URL'] || "http://builds.puppetlabs.lan",
-          :consoleport         => consoleport ? consoleport.to_i : nil,
-          :type                => (ENV['BEAKER_IS_PE'] || ENV['IS_PE']) ? 'pe' : nil,
-          :pe_dir              => ENV['BEAKER_PE_DIR'] || ENV['pe_dist_dir'],
-          :pe_version_file     => ENV['BEAKER_PE_VERSION_FILE'] || ENV['pe_version_file'],
-          :pe_version_file_win => ENV['BEAKER_PE_VERSION_FILE'] || ENV['pe_version_file'],
-          :pe_ver              => ENV['BEAKER_PE_VER'] || ENV['pe_ver'],
-          :forge_host          => ENV['BEAKER_FORGE_HOST'] || ENV['forge_host'],
-          :answers             => {
-                                    :q_puppet_enterpriseconsole_auth_user_email =>
-                                      ENV['q_puppet_enterpriseconsole_auth_user_email'] || 'admin@example.com',
-                                    :q_puppet_enterpriseconsole_auth_password =>
-                                      ENV['q_puppet_enterpriseconsole_auth_password'] || '~!@#$%^*-/ aZ',
-                                    :q_puppet_enterpriseconsole_smtp_host =>
-                                      ENV['q_puppet_enterpriseconsole_smtp_host'],
-                                    :q_puppet_enterpriseconsole_smtp_port =>
-                                      ENV['q_puppet_enterpriseconsole_smtp_port'] || 25,
-                                    :q_puppet_enterpriseconsole_smtp_username =>
-                                      ENV['q_puppet_enterpriseconsole_smtp_username'],
-                                    :q_puppet_enterpriseconsole_smtp_password =>
-                                      ENV['q_puppet_enterpriseconsole_smtp_password'],
-                                    :q_puppet_enterpriseconsole_smtp_use_tls =>
-                                      ENV['q_puppet_enterpriseconsole_smtp_use_tls'] || 'n',
-                                    :q_verify_packages =>
-                                      ENV['q_verify_packages'] || 'y',
-                                    :q_puppetdb_password =>
-                                      ENV['q_puppetdb_password'] || '~!@#$%^*-/ aZ',
-                                  },
-          :package_proxy        => ENV['BEAKER_PACKAGE_PROXY']
-        }.delete_if {|key, value| value.nil? or value.empty? })
+
+        found = munge_found_env_vars( collect_env_vars( ENVIRONMENT_SPEC ))
+
+        return h.merge( found )
       end
 
       # Generates an OptionsHash of preset values for arguments supported by Beaker
@@ -56,53 +90,64 @@ module Beaker
       def self.presets
         h = Beaker::Options::OptionsHash.new
         h.merge({
-          :project             => 'Beaker',
-          :department          => ENV['USER'] || ENV['USERNAME'] || 'unknown',
-          :validate            => true,
-          :jenkins_build_url   => nil,
-          :forge_host          => 'vulcan-acceptance.delivery.puppetlabs.net',
-          :log_level           => 'verbose',
-          :trace_limit         => 10,
-          :hosts_file          => 'sample.cfg',
-          :options_file        => nil,
-          :type                => 'pe',
-          :provision           => true,
-          :preserve_hosts      => 'never',
-          :root_keys           => false,
-          :quiet               => false,
-          :project_root        => File.expand_path(File.join(File.dirname(__FILE__), "../")),
-          :xml_dir             => 'junit',
-          :xml_file            => 'beaker_junit.xml',
-          :xml_stylesheet      => 'junit.xsl',
-          :log_dir             => 'log',
-          :color               => true,
-          :dry_run             => false,
-          :timeout             => 300,
-          :fail_mode           => 'slow',
-          :timesync            => false,
-          :repo_proxy          => false,
-          :package_proxy       => false,
-          :add_el_extras       => false,
-          :consoleport         => 443,
-          :pe_dir              => '/opt/enterprise/dists',
-          :pe_version_file     => 'LATEST',
-          :pe_version_file_win => 'LATEST-win',
-          :dot_fog             => File.join(ENV['HOME'], '.fog'),
-          :ec2_yaml            => 'config/image_templates/ec2.yaml',
-          :help                => false,
-          :ssh                 => {
-                                    :config                => false,
-                                    :paranoid              => false,
-                                    :timeout               => 300,
-                                    :auth_methods          => ["publickey"],
-                                    :port                  => 22,
-                                    :forward_agent         => true,
-                                    :keys                  => ["#{ENV['HOME']}/.ssh/id_rsa"],
-                                    :user_known_hosts_file => "#{ENV['HOME']}/.ssh/known_hosts",
-                                  }
+          :project              => 'Beaker',
+          :department           => ENV['USER'] || ENV['USERNAME'] || 'unknown',
+          :validate             => true,
+          :jenkins_build_url    => nil,
+          :forge_host           => 'vulcan-acceptance.delivery.puppetlabs.net',
+          :log_level            => 'verbose',
+          :trace_limit          => 10,
+          :"master-start-curl-retries" => 0,
+          :options_file         => nil,
+          :type                 => 'pe',
+          :provision            => true,
+          :preserve_hosts       => 'never',
+          :root_keys            => false,
+          :quiet                => false,
+          :project_root         => File.expand_path(File.join(File.dirname(__FILE__), "../")),
+          :xml_dir              => 'junit',
+          :xml_file             => 'beaker_junit.xml',
+          :xml_stylesheet       => 'junit.xsl',
+          :log_dir              => 'log',
+          :color                => true,
+          :dry_run              => false,
+          :timeout              => 300,
+          :fail_mode            => 'slow',
+          :timesync             => false,
+          :repo_proxy           => false,
+          :package_proxy        => false,
+          :add_el_extras        => false,
+          :release_apt_repo_url => "http://apt.puppetlabs.com",
+          :release_yum_repo_url => "http://yum.puppetlabs.com",
+          :dev_builds_url       => "http://builds.puppetlabs.lan",
+          :consoleport          => 443,
+          :pe_dir               => '/opt/enterprise/dists',
+          :pe_version_file      => 'LATEST',
+          :pe_version_file_win  => 'LATEST-win',
+          :answers              => {
+                                     :q_puppet_enterpriseconsole_auth_user_email => 'admin@example.com',
+                                     :q_puppet_enterpriseconsole_auth_password   => '~!@#$%^*-/ aZ',
+                                     :q_puppet_enterpriseconsole_smtp_port       => 25,
+                                     :q_puppet_enterpriseconsole_smtp_use_tls    => 'n',
+                                     :q_verify_packages                          => 'y',
+                                     :q_puppetdb_password                        => '~!@#$%^*-/ aZ'
+          },
+          :dot_fog              => File.join(ENV['HOME'], '.fog'),
+          :ec2_yaml             => 'config/image_templates/ec2.yaml',
+          :help                 => false,
+          :collect_perf_data   => false,
+          :ssh                  => {
+                                     :config                => false,
+                                     :paranoid              => false,
+                                     :timeout               => 300,
+                                     :auth_methods          => ["publickey"],
+                                     :port                  => 22,
+                                     :forward_agent         => true,
+                                     :keys                  => ["#{ENV['HOME']}/.ssh/id_rsa"],
+                                     :user_known_hosts_file => "#{ENV['HOME']}/.ssh/known_hosts",
+          }
         })
       end
-
     end
   end
 end

data/lib/beaker/perf.rb

@@ -0,0 +1,58 @@
+module Beaker
+  # The Beaker Perf class. A single instance is created per Beaker run.
+  class Perf
+
+    # Create the Perf instance and runs setup_perf_on_host on all hosts if --collect-perf-data
+    # was used as an option on the Baker command line invocation. Instances of this class do not
+    # hold state and its methods are helpers for remotely executing tasks for performance data
+    # gathering with sysstat/sar
+    #
+    # @param [Array<Host>] hosts All from the configuration
+    # @param [Hash] options Options to alter execution
+    # @return [void]
+    def initialize( hosts, options )
+      @hosts = hosts
+      @options = options
+      @logger = options[:logger]
+      @perf_timestamp = Time.now
+      @hosts.map { |h| setup_perf_on_host(h) }
+    end
+
+    # Some systems need special modification to make sysstat work. This is done here.
+    # @param [Host] host The host we are working with
+    # @return [void]
+    def setup_perf_on_host(host)
+      @logger.perf_output("Setup perf on host: " + host)
+      if host['platform'] =~ /debian|ubuntu/
+        @logger.perf_output("Modify /etc/default/sysstat on Debian and Ubuntu platforms")
+        host.exec(Command.new('sed -i s/ENABLED=\"false\"/ENABLED=\"true\"/ /etc/default/sysstat'))
+      elsif host['platform'] =~ /sles/
+        @logger.perf_output("Creating symlink from /etc/sysstat/sysstat.cron to /etc/cron.d")
+        host.exec(Command.new('ln -s /etc/sysstat/sysstat.cron /etc/cron.d'),:acceptable_exit_codes => [0,1])
+      end
+      if host['platform'] =~ /debian|ubuntu|redhat|centos/ # SLES doesn't need this step
+        host.exec(Command.new('service sysstat start'))
+      end
+    end
+
+    # Iterate over all hosts, calling get_perf_data
+    # @param [void]
+    # @return [void]
+    def print_perf_info()
+      @perf_end_timestamp = Time.now
+      @hosts.map { |h| get_perf_data(h, @perf_timestamp, @perf_end_timestamp) }
+    end
+
+    # If host is a supported (ie linux) platform, generate a performance report
+    # @param [Host] host The host we are working with
+    # @param [Time] perf_start The beginning time for the SAR report
+    # @param [Time] perf_end   The ending time for the SAR report
+    # @return [void]  The report is sent to the logging output
+    def get_perf_data(host, perf_start, perf_end)
+      @logger.perf_output("Getting perf data for host: " + host)
+      if host['platform'] =~ /debian|ubuntu|redhat|centos|sles/
+        host.exec(Command.new("sar -A -s #{perf_start.strftime("%H:%M:%S")} -e #{perf_end.strftime("%H:%M:%S")}"))
+      end
+    end
+  end
+end

data/lib/beaker/shared/host_manager.rb

@@ -0,0 +1,81 @@
+module Beaker
+  module Shared
+    #Methods for managing Hosts.
+    #- selecting hosts by role (Symbol or String)
+    #- selecting hosts by name (String)
+    #- adding additional method definitions for selecting by role
+    #- executing blocks of code against selected sets of hosts
+    module HostManager
+
+      #Find hosts from a given array of hosts that all have the desired role.
+      #@param [Array<Host>] hosts The hosts to examine
+      #@param [String] desired_role The hosts returned will have this role in their roles list
+      #@return [Array<Host>] The hosts that have the desired role in their roles list
+      def hosts_with_role(hosts, desired_role = nil)
+        hosts.select do |host|
+          desired_role.nil? or host['roles'].include?(desired_role.to_s)
+        end
+      end
+
+      #Find hosts from a given array of hosts that all have the desired name.
+      #@param [Array<Host>] hosts The hosts to examine
+      #@param [String] name The hosts returned will have this name
+      #@return [Array<Host>] The hosts that have the desired name
+      def hosts_with_name(hosts, name = nil)
+        hosts.select do |host|
+          name.nil? or host.name =~ /\A#{name}/
+        end
+      end
+
+      #Find a single host with the role provided.  Raise an error if more than one host is found to have the
+      #provided role.
+      #@param [Array<Host>] hosts The hosts to examine
+      #@param [String] role The host returned will have this role in its role list
+      #@return [Host] The single host with the desired role in its roles list
+      #@raise [ArgumentError] Raised if more than one host has the given role defined, or if no host has the
+      #                       role defined.
+      def only_host_with_role(hosts, role)
+        a_host = hosts_with_role(hosts, role)
+        case
+          when a_host.length == 0
+            raise ArgumentError, "There should be one host with #{role} defined!"
+          when a_host.length > 1
+            host_string = ( a_host.map { |host| host.name } ).join( ', ')
+            raise ArgumentError, "There should be only one host with #{role} defined, but I found #{a_host.length} (#{host_string})"
+        end
+        a_host.first
+      end
+
+      #Execute a block selecting the hosts that match with the provided criteria
+      #@param [Array<Host>, Host] hosts The host or hosts to run the provided block against
+      #@param [String, Symbol] filter Optional filter to apply to provided hosts - limits by name or role
+      #@param [Block] block This method will yield to a block of code passed by the caller
+      def run_block_on hosts = [], filter = nil, &block
+        result = nil
+        block_hosts = hosts #the hosts to apply the block to after any filtering
+        if filter
+          if not hosts.empty?
+            block_hosts = hosts_with_role(hosts, filter) #check by role
+            if block_hosts.empty?
+              block_hosts = hosts_with_name(hosts, filter) #check by name
+            end
+            if block_hosts.length == 1  #we only found one matching host, don't need it wrapped in an array
+              block_hosts = block_hosts.pop
+            end
+          else
+            raise ArgumentError, "Unable to sort for #{filter} type hosts when provided with [] as Hosts"
+          end
+        end
+        if block_hosts.is_a? Array
+          result = block_hosts.map do |h|
+            run_block_on h, nil, &block
+          end
+        else
+          result = yield block_hosts
+        end
+        result
+      end
+
+    end
+  end
+end

data/lib/beaker/shared.rb

@@ -1,10 +1,10 @@
-[ 'repetition', 'error_handler', 'host_role_parser', 'timed' ].each do |lib|
+[ 'repetition', 'error_handler', 'host_manager', 'timed' ].each do |lib|
   require "beaker/shared/#{lib}"
 end
 module Beaker
   module Shared
     include Beaker::Shared::ErrorHandler
-    include Beaker::Shared::HostRoleParser
+    include Beaker::Shared::HostManager
     include Beaker::Shared::Repetition
     include Beaker::Shared::Timed
   end

data/lib/beaker/ssh_connection.rb

@@ -94,6 +94,7 @@ module Beaker
       @ssh.loop
 
       result.finalize!
+      @logger.last_result = result
       result
     end
 
@@ -165,14 +166,17 @@ module Beaker
     def scp_to source, target, options = {}, dry_run = false
       return if dry_run
 
-      options[:recursive]=File.directory?(source) if options[:recursive].nil?
-
-      @ssh.scp.upload! source, target, options
+      options[:recursive]  = File.directory?(source) if options[:recursive].nil?
+      options[:chunk_size] = options[:chunk_size] || 16384
 
       result = Result.new(@hostname, [source, target])
+      result.stdout = "\n"
+      @ssh.scp.upload! source, target, options do |ch, name, sent, total|
+        result.stdout << "\tcopying %s: %10d/%d\n" % [name, sent, total]
+      end
 
       # Setting these values allows reporting via result.log(test_name)
-      result.stdout = "SCP'ed file #{source} to #{@hostname}:#{target}"
+      result.stdout << "  SCP'ed file #{source} to #{@hostname}:#{target}"
 
       # Net::Scp always returns 0, so just set the return code to 0.
       result.exit_code = 0
@@ -185,13 +189,16 @@ module Beaker
       return if dry_run
 
       options[:recursive] = true if options[:recursive].nil?
-
-      @ssh.scp.download! source, target, options
+      options[:chunk_size] = options[:chunk_size] || 16384
 
       result = Result.new(@hostname, [source, target])
+      result.stdout = "\n"
+      @ssh.scp.download! source, target, options do |ch, name, sent, total|
+        result.stdout << "\tcopying %s: %10d/%d\n" % [name, sent, total]
+      end
 
       # Setting these values allows reporting via result.log(test_name)
-      result.stdout = "SCP'ed file #{@hostname}:#{source} to #{target}"
+      result.stdout << "  SCP'ed file #{@hostname}:#{source} to #{target}"
 
       # Net::Scp always returns 0, so just set the return code to 0.
       result.exit_code = 0

data/lib/beaker/test_case.rb

@@ -55,6 +55,9 @@ module Beaker
     #The full log for this test
     attr_accessor :sublog
 
+    #The result for the last command run
+    attr_accessor :last_result
+
     # A Hash of 'product name' => 'version installed', only set when
     # products are installed via git or PE install steps. See the 'git' or
     # 'pe' directories within 'ROOT/setup' for examples.
@@ -121,6 +124,15 @@ module Beaker
       class << self
         def run_test
           @logger.start_sublog
+          @logger.last_result = nil
+
+          #add arbitrary role methods
+          roles = []
+          @hosts.each do |host|
+            roles << host[:roles]
+          end
+          add_role_def( roles.flatten.uniq )
+
           @runtime = Benchmark.realtime do
             begin
               test = File.read(path)
@@ -145,6 +157,7 @@ module Beaker
             end
           end
           @sublog = @logger.get_sublog
+          @last_result = @logger.last_result
           return self
         end
 

data/lib/beaker/test_suite.rb

@@ -155,6 +155,20 @@ module Beaker
         text.gsub(/(\e|\^\[)\[(\d*;)*\d*m/, '')
       end
 
+      # Escape invalid XML UTF-8 codes from provided string, see http://www.w3.org/TR/xml/#charsets for valid
+      # character specification
+      # @param [String] string The string to remove invalid codes from
+      def escape_invalid_xml_chars string
+        re = /\u0009|\u000A|\u000D|[\u0020-\uD7FF]|[\uE000-\uFFFD]|[\u10000-\u10FFFF]/
+        return string.chars.map{|i| i =~ re ? i : "\\#{i.unpack("U*").join}"}.join
+      end
+
+      # Remove color codes and invalid XML characters from provided string
+      # @param [String] string The string to format
+      def format_cdata string
+        escape_invalid_xml_chars(strip_color_codes(string))
+      end
+
       #Format and print the {TestSuiteResult} as JUnit XML
       #@param [String] xml_file The full path to print the output to.
       #@param [String] stylesheet The full path to a JUnit XML stylesheet
@@ -178,7 +192,8 @@ module Beaker
             end
           else
             #no existing file, create a new one
-            doc = Nokogiri::XML::Document.new
+            doc = Nokogiri::XML::Document.new()
+            doc.encoding = 'UTF-8'
             pi = Nokogiri::XML::ProcessingInstruction.new(doc, "xml-stylesheet", "type=\"text/xsl\" href=\"#{File.basename(stylesheet)}\"")
             pi.parent = doc
             suites = Nokogiri::XML::Node.new('testsuites', doc)
@@ -217,7 +232,8 @@ module Beaker
               status['type'] =  test.test_status.to_s
               if test.exception then
                 status['message'] = test.exception.to_s.gsub(/\e/, '')
-                status.add_child(status.document.create_cdata(test.exception.backtrace.join('\n')))
+                data = format_cdata(test.exception.backtrace.join('\n'))
+                status.add_child(status.document.create_cdata(data))
               end
               item.add_child(status)
             end
@@ -236,13 +252,15 @@ module Beaker
 
             if test.sublog then
               stdout = Nokogiri::XML::Node.new('system-out', doc)
-              stdout.add_child(stdout.document.create_cdata(strip_color_codes(test.sublog)))
+              data = format_cdata(test.sublog)
+              stdout.add_child(stdout.document.create_cdata(data))
               item.add_child(stdout)
             end
 
-            if test.stderr then
+            if test.last_result and test.last_result.stderr and not test.last_result.stderr.empty? then
               stderr = Nokogiri::XML::Node.new('system-err', doc)
-              stderr.add_child(stderr.document.create_cdata(strip_color_codes(test.stderr)))
+              data = format_cdata(test.last_result.stderr)
+              stderr.add_child(stderr.document.create_cdata(data))
               item.add_child(stderr)
             end
 

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '1.16.0'
+    STRING = '1.17.0'
   end
 end

data/lib/beaker.rb

@@ -1,7 +1,7 @@
 require 'rubygems' unless defined?(Gem)
 module Beaker
 
-  %w( version platform test_suite result command options network_manager cli ).each do |lib|
+  %w( version platform test_suite result command options network_manager cli perf ).each do |lib|
     begin
       require "beaker/#{lib}"
     rescue LoadError

data/spec/beaker/answers_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Beaker
   describe Answers do
     let( :basic_hosts ) { make_hosts( { 'pe_ver' => @ver } ) }
-    let( :options )     { Beaker::Options::Presets.env_vars }
+    let( :options )     { Beaker::Options::Presets.presets }
     let( :hosts )       { basic_hosts[0]['roles'] = ['master', 'database', 'dashboard']
                           basic_hosts[1]['platform'] = 'windows'
                           basic_hosts }
@@ -59,7 +59,7 @@ module Beaker
 
   module Answers
     describe Version34 do
-      let( :options )     { Beaker::Options::Presets.env_vars }
+      let( :options )     { Beaker::Options::Presets.presets }
       let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
       let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
                       basic_hosts[1]['roles'] = ['dashboard', 'agent']
@@ -73,10 +73,17 @@ module Beaker
           expect( host[:answers] ).to be === answers[host.name]
         end
       end
+
+      it 'should add q_jvm_puppetmaster to the master answers' do
+        @ver = '3.4'
+        answers = subject.answers( hosts, master_certname, options )
+        expect( subject.answers( hosts, master_certname, options )['vm1']).to include :q_jvm_puppetmaster
+      end
+
     end
 
     describe Version32 do
-      let( :options )     { Beaker::Options::Presets.env_vars }
+      let( :options )     { Beaker::Options::Presets.presets }
       let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
       let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
                       basic_hosts[1]['roles'] = ['dashboard', 'agent']
@@ -106,7 +113,7 @@ module Beaker
     end
 
     describe Version30 do
-      let( :options )     { Beaker::Options::Presets.env_vars }
+      let( :options )     { Beaker::Options::Presets.presets }
       let( :basic_hosts ) { make_hosts( { 'pe_ver' => @ver } ) }
       let( :hosts )       { basic_hosts[0]['roles'] = ['master', 'database', 'dashboard']
                             basic_hosts[1]['platform'] = 'windows'
@@ -142,7 +149,7 @@ module Beaker
     end
 
     describe Version28 do
-      let( :options )     { Beaker::Options::Presets.env_vars }
+      let( :options )     { Beaker::Options::Presets.presets }
       let( :basic_hosts ) { make_hosts( { 'pe_ver' => @ver } ) }
       let( :hosts )       { basic_hosts[0]['roles'] = ['master', 'database', 'dashboard']
                             basic_hosts[1]['platform'] = 'windows'
@@ -174,7 +181,7 @@ module Beaker
 
     end
     describe Version20 do
-      let( :options )     { Beaker::Options::Presets.env_vars }
+      let( :options )     { Beaker::Options::Presets.presets }
       let( :basic_hosts ) { make_hosts( { 'pe_ver' => @ver } ) }
       let( :hosts )       { basic_hosts[0]['roles'] = ['master', 'database', 'dashboard']
                             basic_hosts[1]['platform'] = 'windows'
@@ -203,8 +210,6 @@ module Beaker
           expect( host[:answers] ).to be === answers[host.name]
         end
       end
-
     end
-
   end
 end