beaker 3.12.0 → 3.13.0

data/lib/beaker/cli.rb

@@ -9,8 +9,16 @@ module Beaker
     |   V   |
     |   |   | "
 
+    attr_reader :logger
     def initialize
       @timestamp = Time.now
+      # Initialize a logger object prior to parsing; this should be overwritten whence
+      # the options are parsed and replaced with a new logger based on what is passed
+      # in to configure the logger.
+      @logger = Beaker::Logger.new
+    end
+
+    def parse_options
       @options_parser = Beaker::Options::Parser.new
       @options = @options_parser.parse_args
       @attribution = @options_parser.attribution
@@ -20,28 +28,19 @@ module Beaker
       @options_parser.update_option(:timestamp, @timestamp, 'runtime')
       @options_parser.update_option(:beaker_version, Beaker::Version::STRING, 'runtime')
       beaker_version_string = VERSION_STRING % @options[:beaker_version]
-      @execute = true
 
       if @options[:help]
         @logger.notify(@options_parser.usage)
         @execute = false
-        return
+        return self
       end
 
       if @options[:beaker_version_print]
         @logger.notify(beaker_version_string)
         @execute = false
-        return
+        return self
       end
 
-      @logger.info("Beaker!")
-      @logger.info(beaker_version_string)
-      @logger.info(@options.dump)
-
-      if @options[:parse_only]
-        @execute = false
-        return
-      end
 
       #add additional paths to the LOAD_PATH
       if not @options[:load_path].empty?
@@ -53,6 +52,21 @@ module Beaker
         require File.expand_path(helper)
       end
 
+      if @options[:parse_only]
+        print_version_and_options
+        @execute = false
+        return self
+      end
+
+      @execute = true
+      self
+    end
+
+    # only call this method after parse_options has been executed.
+    def print_version_and_options
+      @logger.info("Beaker!")
+      @logger.info(VERSION_STRING % @options[:beaker_version])
+      @logger.info(@options.dump)
     end
 
     #Provision, validate and configure all hosts as defined in the hosts file
@@ -77,10 +91,12 @@ module Beaker
     # - run post-suite
     # - cleanup hosts
     def execute!
-
       if !@execute
         return
       end
+
+      print_version_and_options
+
       begin
         trap(:INT) do
           @logger.warn "Interrupt received; exiting..."

data/lib/beaker/dsl.rb

@@ -1,5 +1,5 @@
 [ 'install_utils', 'roles', 'outcomes', 'assertions', 'patterns',
-  'structure', 'helpers', 'wrappers' ].each do |lib|
+  'structure', 'helpers', 'wrappers', 'test_tagging' ].each do |lib|
   require "beaker/dsl/#{lib}"
 end
 
@@ -79,6 +79,7 @@ module Beaker
     include Beaker::DSL::Helpers
     include Beaker::DSL::InstallUtils
     include Beaker::DSL::Patterns
+    include Beaker::DSL::TestTagging
 
     def self.register(helper_module)
       include helper_module

data/lib/beaker/dsl/helpers/puppet_helpers.rb

@@ -322,7 +322,7 @@ module Beaker
         # @!visibility private
         def puppet_conf_for host, conf_opts
           puppetconf = host.exec( Command.new( "cat #{host.puppet('master')['config']}" ) ).stdout
-          new_conf   = IniFile.new( puppetconf ).merge( conf_opts )
+          new_conf   = IniFile.new(content: puppetconf).merge( conf_opts )
 
           new_conf
         end

data/lib/beaker/dsl/helpers/tk_helpers.rb

@@ -75,7 +75,7 @@ module Beaker
             end
 
             begin
-              return IniFile.new(string)
+              return IniFile.new(content: string)
             rescue IniFile::Error
               nil
             end

data/lib/beaker/dsl/structure.rb

@@ -244,63 +244,6 @@ module Beaker
         self.hosts = original_hosts
       end
 
-      # Sets tags on the current {Beaker::TestCase}, and skips testing
-      # if necessary after checking this case's tags against the ones that are
-      # being included or excluded.
-      #
-      # @param [Array<String>] tags Tags to be assigned to the current test
-      #
-      # @return nil
-      # @api public
-      def tag(*tags)
-        metadata[:case] ||= {}
-        metadata[:case][:tags] = []
-        tags.each do |tag|
-          metadata[:case][:tags] << tag.downcase
-        end
-
-        @options[:tag_includes] ||= []
-        @options[:tag_excludes] ||= []
-
-        tags_needed_to_include_this_test = []
-        @options[:tag_includes].each do |tag_to_include|
-          tags_needed_to_include_this_test << tag_to_include \
-            unless metadata[:case][:tags].include?(tag_to_include)
-        end
-        skip_test "#{self.path} does not include necessary tag(s): #{tags_needed_to_include_this_test}" \
-          if tags_needed_to_include_this_test.length > 0
-
-        tags_to_remove_to_include_this_test = []
-        @options[:tag_excludes].each do |tag_to_exclude|
-          tags_to_remove_to_include_this_test << tag_to_exclude \
-            if metadata[:case][:tags].include?(tag_to_exclude)
-        end
-        skip_test "#{self.path} includes excluded tag(s): #{tags_to_remove_to_include_this_test}" \
-          if tags_to_remove_to_include_this_test.length > 0
-
-        platform_specific_tag_confines
-      end
-
-      # Handles platform-specific tag confines logic
-      #
-      # @return nil
-      # @!visibility private
-      def platform_specific_tag_confines
-        @options[:platform_tag_confines_object] ||= PlatformTagConfiner.new(
-          @options[:platform_tag_confines]
-        )
-        confines = @options[:platform_tag_confines_object].confine_details(
-          metadata[:case][:tags]
-        )
-        confines.each do |confine_details|
-          logger.notify( confine_details[:log_message] )
-          confine(
-            confine_details[:type],
-            :platform => confine_details[:platform_regex]
-          )
-        end
-      end
-
       #Return a set of hosts that meet the given criteria
       # @param [Hash{Symbol,String=>String,Regexp,Array<String,Regexp>}]
       #   criteria Specify the criteria with which a host should be
@@ -348,79 +291,6 @@ module Beaker
           true_false
         end
       end
-
-      class PlatformTagConfiner
-
-        # Constructs the PlatformTagConfiner, transforming the user format
-        #   into the internal structure for use by Beaker itself.
-        #
-        # @param [Array<Hash{Symbol=>Object}>] platform_tag_confines_array
-        #   The array of PlatformTagConfines objects that specify how these
-        #   confines should behave. See the note below for more info
-        #
-        # @note PlatformTagConfines objects come in the form
-        #     [
-        #       {
-        #         :platform => <platform-regex>,
-        #         :tag_reason_hash => {
-        #           <tag> => <reason to confine>,
-        #           <tag> => <reason to confine>,
-        #           ...etc...
-        #         }
-        #       }
-        #     ]
-        #
-        #   Internally, we want to turn tag matches into platform
-        #     confine statements. So a better internal structure would
-        #     be something of the form:
-        #     {
-        #       <tag> => [{
-        #         :platform => <platform-regex>,
-        #         :reason => <reason to confine>,
-        #         :type => :except,
-        #       }, ... ]
-        #     }
-        def initialize(platform_tag_confines_array)
-          platform_tag_confines_array ||= []
-          @tag_confine_details_hash = {}
-          platform_tag_confines_array.each do |entry|
-            entry[:tag_reason_hash].keys.each do |tag|
-              @tag_confine_details_hash[tag] ||= []
-              log_msg = "Tag '#{tag}' found, confining: except platforms "
-              log_msg << "matching regex '#{entry[:platform]}'. Reason: "
-              log_msg << "'#{entry[:tag_reason_hash][tag]}'"
-              @tag_confine_details_hash[tag] << {
-                :platform_regex => entry[:platform],
-                :log_message => log_msg,
-                :type => :except
-              }
-            end
-          end
-        end
-
-        # Gets the confine details needed for a set of tags
-        #
-        # @param [Array<String>] tags Tags of the given test
-        #
-        # @return [Array<Hash{Symbol=>Object}>] an array of
-        #   Confine details hashes, which are hashes of symbols
-        #   to their properties, which are objects of various
-        #   kinds, depending on the key
-        def confine_details(tags)
-          tags ||= []
-          details = []
-          tags.each do |tag|
-            tag_confine_array = @tag_confine_details_hash[tag]
-            next if tag_confine_array.nil?
-
-            details.push( *tag_confine_array )
-            # tag_confine_array.each do |confine_details|
-            #   details << confine_details
-            # end
-          end
-          details
-        end
-      end
     end
   end
 end

data/lib/beaker/dsl/test_tagging.rb

@@ -0,0 +1,157 @@
+module Beaker
+  module DSL
+    # Test Tagging is about applying meta-data to tests (using the #tag method),
+    # so that you can control which tests are executed in a particular beaker
+    # run at a more fine-grained level.
+    #
+    # @note There are a few places where TestTagging-related code is located:
+    #   - {Beaker::Options::Parser#normalize_tags!} makes sure the test tags
+    #     are formatted correctly for use in this module
+    #   - {Beaker::Options::CommandLineParser#initialize} parses test tagging
+    #     options
+    #   - {Beaker::Options::Validator#validate_tags} ensures test tag CLI params
+    #     are valid for use by this module
+    module TestTagging
+
+      # Sets tags on the current {Beaker::TestCase}, and skips testing
+      # if necessary after checking this case's tags against the ones that are
+      # being included or excluded.
+      #
+      # @param [Array<String>] tags Tags to be assigned to the current test
+      #
+      # @return nil
+      # @api public
+      def tag(*tags)
+        metadata[:case] ||= {}
+        metadata[:case][:tags] = []
+        tags.each do |tag|
+          metadata[:case][:tags] << tag.downcase
+        end
+
+        @options[:test_tag_and]     ||= []
+        @options[:test_tag_or]      ||= []
+        @options[:test_tag_exclude] ||= []
+
+        tags_needed_to_include_this_test = []
+        @options[:test_tag_and].each do |tag_to_include|
+          tags_needed_to_include_this_test << tag_to_include \
+            unless metadata[:case][:tags].include?(tag_to_include)
+        end
+        skip_test "#{self.path} does not include necessary tag(s): #{tags_needed_to_include_this_test}" \
+          if tags_needed_to_include_this_test.length > 0
+
+        found_test_tag = false
+        @options[:test_tag_or].each do |tag_to_include|
+          found_test_tag = metadata[:case][:tags].include?(tag_to_include)
+          break if found_test_tag
+        end
+        skip_test "#{self.path} does not include any of these tag(s): #{@options[:test_tag_or]}" \
+          if @options[:test_tag_or].length > 0 && !found_test_tag
+
+        tags_to_remove_to_include_this_test = []
+        @options[:test_tag_exclude].each do |tag_to_exclude|
+          tags_to_remove_to_include_this_test << tag_to_exclude \
+            if metadata[:case][:tags].include?(tag_to_exclude)
+        end
+        skip_test "#{self.path} includes excluded tag(s): #{tags_to_remove_to_include_this_test}" \
+          if tags_to_remove_to_include_this_test.length > 0
+
+        platform_specific_tag_confines
+      end
+
+      # Handles platform-specific tag confines logic
+      #
+      # @return nil
+      # @!visibility private
+      def platform_specific_tag_confines
+        @options[:platform_tag_confines_object] ||= PlatformTagConfiner.new(
+          @options[:platform_tag_confines]
+        )
+        confines = @options[:platform_tag_confines_object].confine_details(
+          metadata[:case][:tags]
+        )
+        confines.each do |confine_details|
+          logger.notify( confine_details[:log_message] )
+          confine(
+            confine_details[:type],
+            :platform => confine_details[:platform_regex]
+          )
+        end
+      end
+
+      class PlatformTagConfiner
+
+        # Constructs the PlatformTagConfiner, transforming the user format
+        #   into the internal structure for use by Beaker itself.
+        #
+        # @param [Array<Hash{Symbol=>Object}>] platform_tag_confines_array
+        #   The array of PlatformTagConfines objects that specify how these
+        #   confines should behave. See the note below for more info
+        #
+        # @note PlatformTagConfines objects come in the form
+        #     [
+        #       {
+        #         :platform => <platform-regex>,
+        #         :tag_reason_hash => {
+        #           <tag> => <reason to confine>,
+        #           <tag> => <reason to confine>,
+        #           ...etc...
+        #         }
+        #       }
+        #     ]
+        #
+        #   Internally, we want to turn tag matches into platform
+        #     confine statements. So a better internal structure would
+        #     be something of the form:
+        #     {
+        #       <tag> => [{
+        #         :platform => <platform-regex>,
+        #         :reason => <reason to confine>,
+        #         :type => :except,
+        #       }, ... ]
+        #     }
+        def initialize(platform_tag_confines_array)
+          platform_tag_confines_array ||= []
+          @tag_confine_details_hash = {}
+          platform_tag_confines_array.each do |entry|
+            entry[:tag_reason_hash].keys.each do |tag|
+              @tag_confine_details_hash[tag] ||= []
+              log_msg = "Tag '#{tag}' found, confining: except platforms "
+              log_msg << "matching regex '#{entry[:platform]}'. Reason: "
+              log_msg << "'#{entry[:tag_reason_hash][tag]}'"
+              @tag_confine_details_hash[tag] << {
+                :platform_regex => entry[:platform],
+                :log_message => log_msg,
+                :type => :except
+              }
+            end
+          end
+        end
+
+        # Gets the confine details needed for a set of tags
+        #
+        # @param [Array<String>] tags Tags of the given test
+        #
+        # @return [Array<Hash{Symbol=>Object}>] an array of
+        #   Confine details hashes, which are hashes of symbols
+        #   to their properties, which are objects of various
+        #   kinds, depending on the key
+        def confine_details(tags)
+          tags ||= []
+          details = []
+          tags.each do |tag|
+            tag_confine_array = @tag_confine_details_hash[tag]
+            next if tag_confine_array.nil?
+
+            details.push( *tag_confine_array )
+            # tag_confine_array.each do |confine_details|
+            #   details << confine_details
+            # end
+          end
+          details
+        end
+      end
+
+    end
+  end
+end

data/lib/beaker/host/unix/exec.rb

@@ -246,7 +246,15 @@ module Unix::Exec
       else
         val = val.to_s
       end
-      env_array << "#{key.to_s.upcase}=\"#{val}\""
+      # doing this for the key itself & the upcase'd version allows us to remain
+      # backwards compatible
+      # TODO: (Next Major Version) get rid of upcase'd version
+      key_str = key.to_s
+      keys = [key_str]
+      keys << key_str.upcase if key_str.upcase != key_str
+      keys.each do |env_key|
+        env_array << "#{env_key}=\"#{val}\""
+      end
     end
     env_array
   end

data/lib/beaker/host_prebuilt_steps.rb

@@ -173,7 +173,7 @@ module Beaker
         elsif host['platform'] =~ /aix/
           host.exec(Command.new(ROOT_KEYS_SYNC_CMD_AIX % "env PATH=/usr/gnu/bin:$PATH bash"), :accept_all_exit_codes => true)
         else
-          host.exec(Command.new(ROOT_KEYS_SYNC_CMD % "env PATH=/usr/gnu/bin:$PATH bash"), :accept_all_exit_codes => true)
+          host.exec(Command.new(ROOT_KEYS_SYNC_CMD % "env PATH=\"/usr/gnu/bin:$PATH\" bash"), :accept_all_exit_codes => true)
         end
       end
     rescue => e

data/lib/beaker/hypervisor/openstack.rb

@@ -220,16 +220,15 @@ module Beaker
 
       @hosts.each do |host|
         ip = get_ip
-        host[:vmhostname] = ip.ip.gsub '.','-'
-        host[:vmfqdn] = host[:vmhostname] + '.rfc1918.puppetlabs.net'
+        host[:vmhostname] = ip.ip.gsub('.','-') + '.rfc1918.puppetlabs.net'
         host[:keyname] = key_name(host)
-        @logger.debug "Provisioning #{host.name} (#{host[:vmfqdn]})"
+        @logger.debug "Provisioning #{host.name} (#{host[:vmhostname]})"
         options = {
           :flavor_ref => flavor(host[:flavor]).id,
           :image_ref  => image(host[:image]).id,
           :nics       => [ {'net_id' => network(@options[:openstack_network]).id } ],
-          :name       => host[:vmfqdn],
-          :hostname   => host[:vmfqdn],
+          :name       => host[:vmhostname],
+          :hostname   => host[:vmhostname],
           :user_data  => host[:user_data] || "#cloud-config\nmanage_etc_hosts: true\n",
           :key_name   => host[:keyname],
         }
@@ -247,10 +246,10 @@ module Beaker
             break
           rescue Fog::Errors::TimeoutError => e
             if try >= attempts
-              @logger.debug "Failed to connect to new OpenStack instance #{host.name} (#{host[:vmfqdn]})"
+              @logger.debug "Failed to connect to new OpenStack instance #{host.name} (#{host[:vmhostname]})"
               raise e
             end
-            @logger.debug "Timeout connecting to instance #{host.name} (#{host[:vmfqdn]}), trying again..."
+            @logger.debug "Timeout connecting to instance #{host.name} (#{host[:vmhostname]}), trying again..."
           end
           sleep SLEEPWAIT
           try += 1
@@ -260,7 +259,7 @@ module Beaker
         ip.server = vm
         host[:ip] = ip.ip
 
-        @logger.debug "OpenStack host #{host.name} (#{host[:vmfqdn]}) assigned ip: #{host[:ip]}"
+        @logger.debug "OpenStack host #{host.name} (#{host[:vmhostname]}) assigned ip: #{host[:ip]}"
 
         #set metadata
         vm.metadata.update({:jenkins_build_url => @options[:jenkins_build_url].to_s,
@@ -332,7 +331,7 @@ module Beaker
     #@api private
     def key_name(host)
       if @options[:openstack_keyname]
-        @logger.debug "Adding optional key_name #{@options[:openstack_keyname]} to #{host.name} (#{host[:vmfqdn]})"
+        @logger.debug "Adding optional key_name #{@options[:openstack_keyname]} to #{host.name} (#{host[:vmhostname]})"
         @options[:openstack_keyname]
       else
         @logger.debug "Generate a new rsa key"