beaker 3.12.0 → 3.13.0

data/lib/beaker/options/command_line_parser.rb

@@ -245,12 +245,27 @@ module Beaker
             @cmd_options[:type] = type
           end
 
-          opts.on '--tag TAGS', 'Run the set of tests matching ALL of the provided single or comma separated list of tags' do |value|
-            @cmd_options[:tag_includes] = value
+          opts.on '--tag TAGS',
+                  'DEPRECATED - use --test-tag-and instead' do |value|
+            @cmd_options[:test_tag_and] = value
+          end
+          opts.on '--test-tag-and TAGS',
+                  'Run the set of tests matching ALL of the provided single or comma separated list of tags' do |value|
+            @cmd_options[:test_tag_and] = value
+          end
+
+          opts.on '--test-tag-or TAGS',
+                  'Run the set of tests matching ANY of the provided single or comma separated list of tags' do |value|
+            @cmd_options[:test_tag_or] = value
           end
 
-          opts.on '--exclude-tag TAGS', 'Run the set of tests that do not contain ANY of the provided single or command separated list of tags' do |value|
-            @cmd_options[:tag_excludes] = value
+          opts.on '--exclude-tag TAGS',
+                  'DEPRECATED - use --test-tag-exclude instead' do |value|
+            @cmd_options[:test_tag_exclude] = value
+          end
+          opts.on '--test-tag-exclude TAGS',
+                  'Run the set of tests that do not contain ANY of the provided single or comma separated list of tags' do |value|
+            @cmd_options[:test_tag_exclude] = value
           end
 
           opts.on '--xml-time-order',

data/lib/beaker/options/parser.rb

@@ -363,8 +363,12 @@ module Beaker
           host[:host_tags] = @options[:host_tags].merge(host[:host_tags] || {})
         end
 
-        normalize_tags!
-        @validator.validate_tags(@options[:tag_includes], @options[:tag_excludes])
+        normalize_test_tags!
+        @validator.validate_test_tags(
+          @options[:test_tag_and],
+          @options[:test_tag_or],
+          @options[:test_tag_exclude]
+        )
         resolve_symlinks!
 
         #set the default role
@@ -411,13 +415,18 @@ module Beaker
 
       # Normalize include and exclude tags. This modifies @options.
       #
-      def normalize_tags!
-        @options[:tag_includes] ||= ''
-        @options[:tag_excludes] ||= ''
-        @options[:tag_includes] = @options[:tag_includes].split(',') if @options[:tag_includes].respond_to?(:split)
-        @options[:tag_excludes] = @options[:tag_excludes].split(',') if @options[:tag_excludes].respond_to?(:split)
-        @options[:tag_includes].map!(&:downcase)
-        @options[:tag_excludes].map!(&:downcase)
+      # @note refer to {Beaker::DSL::TestTagging} for test tagging implementation
+      #
+      def normalize_test_tags!
+        @options[:test_tag_and]     ||= ''
+        @options[:test_tag_or]      ||= ''
+        @options[:test_tag_exclude] ||= ''
+        @options[:test_tag_and]     = @options[:test_tag_and].split(',')     if @options[:test_tag_and].respond_to?(:split)
+        @options[:test_tag_or]      = @options[:test_tag_or].split(',')      if @options[:test_tag_or].respond_to?(:split)
+        @options[:test_tag_exclude] = @options[:test_tag_exclude].split(',') if @options[:test_tag_exclude].respond_to?(:split)
+        @options[:test_tag_and].map!(&:downcase)
+        @options[:test_tag_or].map!(&:downcase)
+        @options[:test_tag_exclude].map!(&:downcase)
       end
 
       private

data/lib/beaker/options/presets.rb

@@ -34,8 +34,9 @@ module Beaker
         :release_yum_repo_url => ['BEAKER_RELEASE_YUM_REPO', 'RELEASE_YUM_REPO'],
         :dev_builds_url       => ['BEAKER_DEV_BUILDS_URL', 'DEV_BUILDS_URL'],
         :vbguest_plugin       => ['BEAKER_VB_GUEST_PLUGIN', 'BEAKER_vb_guest_plugin'],
-        :tag_includes         => ['BEAKER_TAG'],
-        :tag_excludes         => ['BEAKER_EXCLUDE_TAG'],
+        :test_tag_and         => ['BEAKER_TAG', 'BEAKER_TEST_TAG_AND'],
+        :test_tag_or          => ['BEAKER_TEST_TAG_OR'],
+        :test_tag_exclude     => ['BEAKER_EXCLUDE_TAG', 'BEAKER_TEST_TAG_EXCLUDE'],
         :run_in_parallel      => ['BEAKER_RUN_IN_PARALLEL'],
       }
 
@@ -157,8 +158,9 @@ module Beaker
           :log_sut_event          => 'sut.log',
           :color                  => true,
           :dry_run                => false,
-          :tag_includes           => '',
-          :tag_excludes           => '',
+          :test_tag_and           => '',
+          :test_tag_or            => '',
+          :test_tag_exclude       => '',
           :timeout                => 900, # 15 minutes
           :fail_mode              => 'slow',
           :accept_all_exit_codes  => false,

data/lib/beaker/options/validator.rb

@@ -81,14 +81,20 @@ module Beaker
 
       # Raise an error if an item exists in both the include and exclude lists.
       #
-      # @param [Array] include included items
-      # @param [Array] exclude excluded items
+      # @note see test tagging logic at {Beaker::DSL::TestTagging} module
+      #
+      # @param [Array] tags_and included items
+      # @param [Array] tags_exclude excluded items
       # @return [nil] Does not return anything
-      def validate_tags(include, exclude)
-        include.each do |included_tag|
+      def validate_test_tags(tags_and, tags_or, tags_exclude)
+        if tags_and.length > 0 && tags_or.length > 0
+          validator_error "cannot have values for both test tagging operands (AND and OR)"
+        end
+
+        tags_and.each do |included_tag|
           # select items from exclude set that match included_tag
           # no match is an empty list/array/[]
-          if exclude.select { |ex| ex == included_tag } != []
+          if tags_exclude.select { |ex| ex == included_tag } != []
             validator_error "tag '#{included_tag}' cannot be in both the included and excluded tag sets"
           end
         end

data/lib/beaker/subcommand.rb

@@ -6,20 +6,98 @@ module Beaker
   class Subcommand < Thor
     SubcommandUtil = Beaker::Subcommands::SubcommandUtil
 
-    desc "init", "Initialises the beaker test environment configuration"
-    option :hypervisor, :type => :string, :enum => %w{vagrant vmpooler}
+    def initialize(*args)
+      super
+      @@config = SubcommandUtil.init_config()
+    end
+
+    # Options listed in this group 'Beaker run' are options that can be set on subcommands
+    # but are not processed by the subcommand itself. They are passed through so that when
+    # a Beaker::CLI object executes, it can pick up these options. Notably excluded from this
+    # group are `help` and `version`. Please note that whenever the command_line_parser.rb is
+    # updated, this list should also be updated as well.
+    class_option :hosts, :aliases => '-h', :type => :string, :group => 'Beaker run'
+    class_option :'options-file', :aliases => '-o', :type => :string, :group => 'Beaker run'
+    class_option :helper, :type => :string, :group => 'Beaker run'
+    class_option :'load-path', :type => :string, :group => 'Beaker run'
+    class_option :tests, :aliases => '-t', :type => :string, :group => 'Beaker run'
+    class_option :'pre-suite', :type => :string, :group => 'Beaker run'
+    class_option :'post-suite', :type => :string, :group => 'Beaker run'
+    class_option :'pre-cleanup', :type => :string, :group => 'Beaker run'
+    class_option :'provision', :type => :boolean, :group => 'Beaker run'
+    class_option :'preserve-hosts', :type => :string, :group => 'Beaker run'
+    class_option :'root-keys', :type => :boolean, :group => 'Beaker run'
+    class_option :keyfile, :type => :string, :group => 'Beaker run'
+    class_option :timeout, :type => :string, :group => 'Beaker run'
+    class_option :install, :aliases => '-i', :type => :string, :group => 'Beaker run'
+    class_option :modules, :aliases => '-m', :type => :string, :group => 'Beaker run'
+    class_option :quiet, :aliases => '-q', :type => :boolean, :group => 'Beaker run'
+    class_option :color, :type => :boolean, :group => 'Beaker run'
+    class_option :'color-host-output', :type => :boolean, :group => 'Beaker run'
+    class_option :'log-level', :type => :string, :group => 'Beaker run'
+    class_option :'log-prefix', :type => :string, :group => 'Beaker run'
+    class_option :'dry-run', :type => :boolean, :group => 'Beaker run'
+    class_option :'fail-mode', :type => :string, :group => 'Beaker run'
+    class_option :ntp, :type => :boolean, :group => 'Beaker run'
+    class_option :'repo-proxy', :type => :boolean, :group => 'Beaker run'
+    class_option :'add-el-extras', :type => :boolean, :group => 'Beaker run'
+    class_option :'package-proxy', :type => :string, :group => 'Beaker run'
+    class_option :'validate', :type => :boolean, :group => 'Beaker run'
+    class_option :'collect-perf-data', :type => :boolean, :group => 'Beaker run'
+    class_option :'parse-only', :type => :boolean, :group => 'Beaker run'
+    class_option :tag, :type => :string, :group => 'Beaker run'
+    class_option :'exclude-tags', :type => :string, :group => 'Beaker run'
+    class_option :'xml-time-order', :type => :boolean, :group => 'Beaker run'
+
+    desc "init HYPERVISOR", "Initialises the beaker test environment configuration"
     option :help, :type => :boolean, :hide => true
     long_desc <<-LONGDESC
-      Initialises a beaker environment configuration
+
+      Initialises a test environment configuration for a specific hypervisor
+
+      Supported hypervisors are: vagrant (default), vmpooler
+
     LONGDESC
-    def init()
+    def init(hypervisor='vagrant')
       if options[:help]
         invoke :help, [], ["init"]
         return
       end
+      SubcommandUtil.verify_init_args(hypervisor)
       SubcommandUtil.require_tasks()
-      SubcommandUtil.init_hypervisor(options)
-      say "Writing host config to .beaker/acceptance/config/default_#{options[:hypervisor]}_hosts.yaml"
+      SubcommandUtil.init_hypervisor(hypervisor)
+      say "Writing host config to .beaker/acceptance/config/default_#{hypervisor}_hosts.yaml"
+      SubcommandUtil.store_config({:hypervisor => hypervisor})
+      SubcommandUtil.delete_config([:provisioned])
+    end
+
+    desc "provision", "Provisions the beaker test configuration"
+    option :validate, :type => :boolean, :default => true
+    option :configure, :type => :boolean, :default => true
+    option :help, :type => :boolean, :hide => true
+    long_desc <<-LONGDESC
+    Provisions a beaker configuration
+    LONGDESC
+    def provision()
+      if options[:help]
+        invoke :help, [], ["provision"]
+        return
+      end
+
+      hypervisor = @@config.transaction { @@config[:hypervisor] }
+
+      unless hypervisor
+        SubcommandUtil.error_with("Please initialise a configuration")
+      end
+
+      provisioned = @@config.transaction { @@config[:provisioned] }
+
+      if !provisioned or options[:force]
+        SubcommandUtil.provision(hypervisor, options)
+        SubcommandUtil.store_config({:provisioned => true})
+      else
+        say "Hosts have already been provisioned"
+      end
     end
   end
 end

data/lib/beaker/subcommands/subcommand_util.rb

@@ -1,5 +1,7 @@
 require 'rake'
 require 'stringio'
+require 'yaml/store'
+require 'fileutils'
 
 module Beaker
   module Subcommands
@@ -18,6 +20,8 @@ module Beaker
     module SubcommandUtil
       BEAKER_REQUIRE = "require 'beaker/tasks/quick_start'"
       HYPERVISORS = ["vagrant", "vmpooler"]
+      CONFIG_DIR = ".beaker"
+      CONFIG_KEYS = [:hypervisor, :provisioned]
 
       # Check if the first argument to the beaker execution is a subcommand
       # @return [Boolean] true if argv[0] is "help" or a method defined in the Subcommands class, false otherwise
@@ -86,17 +90,20 @@ module Beaker
         execute_rake_task("beaker_quickstart:gen_hosts[vmpooler]")
       end
 
-      # Print a message to the console and exit with 0
-      # @param [String] msg the message to print
-      def self.exit_with(msg)
+      # Print a message to the console and exit with specified exit code, defaults to 1
+      # @param [String] msg the message to output
+      # @param [Hash<Object>] options to specify exit code or output stack trace
+      def self.error_with(msg, options={})
         puts msg
-        exit(0)
+        puts options[:stack_trace] if options[:stack_trace]
+        exit_code = options[:exit_code] ? options[:exit_code] : 1
+        exit(exit_code)
       end
 
       # Call the quick start task for the specified hypervisor
-      # @param [Array<Object>] options the options we want to query
-      def self.init_hypervisor(options)
-        case options[:hypervisor]
+      # @param [String] hypervisor the hypervisor we want to query
+      def self.init_hypervisor(hypervisor)
+        case hypervisor
         when "vagrant"
           init_vagrant
         when "vmpooler"
@@ -104,6 +111,14 @@ module Beaker
         end
       end
 
+      # Verify that a valid hypervisor has been specified
+      # @param [String] hypervisor the hypervisor we want to validate
+      def self.verify_init_args(hypervisor)
+        unless HYPERVISORS.include?(hypervisor)
+          error_with("Invalid hypervisor. Currently supported hypervisors are: #{HYPERVISORS.join(', ')}")
+        end
+      end
+
       # Execute a task but capture stdout and stderr to a buffer
       def self.with_captured_output
         begin
@@ -117,6 +132,42 @@ module Beaker
           $stderr = old_stderr
         end
       end
+
+      # Initialise the beaker config
+      def self.init_config()
+        FileUtils.mkdir_p CONFIG_DIR
+        @@store = YAML::Store.new("#{CONFIG_DIR}/config")
+      end
+
+      # Store values from a hash into the beaker config
+      # @param [Hash{Symbol=>String}] config values we want to store
+      def self.store_config(config)
+        @@store.transaction do
+          CONFIG_KEYS.each do |key|
+            @@store[key] = config[key] unless config[key].nil?
+          end
+        end
+      end
+
+      # Delete keys from the beaker configi
+      # @param [Array<Object>] keys the keys we want to delete from the config
+      def self.delete_config(keys)
+        @@store.transaction {
+          keys.each do |key|
+            @@store.delete(key)
+          end
+        }
+      end
+
+      # Reset args and provision nodes
+      # @param [String] hypervisor the hypervisor to use
+      # @param [Array<Object>] options the options to use when provisioning
+      def self.provision(hypervisor, options)
+        reset_argv(["--hosts", "#{CONFIG_DIR}/acceptance/config/default_#{hypervisor}_hosts.yaml", "--validate", options[:validate], "--configure", options[:configure]])
+        beaker = Beaker::CLI.new.parse_options
+        beaker.provision
+        beaker.preserve_hosts_file
+      end
     end
   end
 end

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '3.12.0'
+    STRING = '3.13.0'
   end
 end

data/spec/beaker/cli_spec.rb

@@ -2,9 +2,52 @@ require 'spec_helper'
 
 module Beaker
   describe CLI do
+
+    context 'initializing and parsing' do
+      let( :cli ) {
+        Beaker::CLI.new
+      }
+
+      describe 'instance variable initialization' do
+        it 'creates a logger for use before parse is called' do
+          expect(Beaker::Logger).to receive(:new).once.and_call_original
+          expect(cli.logger).to be_instance_of(Beaker::Logger)
+        end
+
+        it 'generates the timestamp' do
+          expect(Time).to receive(:now).once
+          cli
+        end
+      end
+
+      describe '#parse_options' do
+        it 'returns self' do
+          expect(cli.parse_options).to be_instance_of(Beaker::CLI)
+        end
+
+        it 'replaces the logger object with a new one' do
+          expect(Beaker::Logger).to receive(:new).with(no_args).once.and_call_original
+          expect(Beaker::Logger).to receive(:new).once.and_call_original
+          cli.parse_options
+        end
+      end
+
+      describe '#print_version_and_options' do
+        before do
+          options  = Beaker::Options::OptionsHash.new
+          options[:beaker_version] = 'version_number'
+          cli.instance_variable_set('@options', options)
+        end
+        it 'prints the version and dumps the options' do
+          expect(cli.logger).to receive(:info).exactly(3).times
+          cli.print_version_and_options
+        end
+      end
+    end
+
     let(:cli)      {
       allow(File).to receive(:exists?).and_return(true)
-      Beaker::CLI.new
+      Beaker::CLI.new.parse_options
     }
 
     context 'execute!' do

data/spec/beaker/dsl/structure_spec.rb

@@ -280,217 +280,4 @@ describe ClassMixedWithDSLStructure do
     end
   end
 
-  describe '#tag' do
-    let ( :tag_includes ) { @tag_includes || [] }
-    let ( :tag_excludes ) { @tag_excludes || [] }
-    let ( :options )      {
-      opts = Beaker::Options::OptionsHash.new
-      opts[:tag_includes] = tag_includes
-      opts[:tag_excludes] = tag_excludes
-      opts
-    }
-
-    before :each do
-      allow( subject ).to receive( :platform_specific_tag_confines )
-    end
-
-    it 'sets tags on the TestCase\'s metadata object' do
-      subject.instance_variable_set(:@options, options)
-      tags = ['pants', 'jayjay', 'moguely']
-      subject.tag(*tags)
-      expect( metadata[:case][:tags] ).to be === tags
-    end
-
-    it 'lowercases the tags' do
-      subject.instance_variable_set(:@options, options)
-      tags_upper = ['pANTs', 'jAYJAy', 'moGUYly']
-      tags_lower = tags_upper.map(&:downcase)
-      subject.tag(*tags_upper)
-      expect( metadata[:case][:tags] ).to be === tags_lower
-    end
-
-    it 'skips the test if any of the requested tags isn\'t included in this test' do
-      test_tags = ['pants', 'jayjay', 'moguely']
-      @tag_includes = test_tags.compact.push('needed_tag_not_in_test')
-      subject.instance_variable_set(:@options, options)
-
-      allow( subject ).to receive( :path )
-      expect( subject ).to receive( :skip_test )
-      subject.tag(*test_tags)
-    end
-
-    it 'runs the test if all requested tags are included in this test' do
-      @tag_includes = ['pants_on_head', 'jayjay_jayjay', 'mo']
-      test_tags = @tag_includes.compact.push('extra_asdf')
-      subject.instance_variable_set(:@options, options)
-
-      allow( subject ).to receive( :path )
-      expect( subject ).to receive( :skip_test ).never
-      subject.tag(*test_tags)
-    end
-
-    it 'skips the test if any of the excluded tags are included in this test' do
-      test_tags = ['ports', 'jay_john_mary', 'mog_the_dog']
-      @tag_excludes = [test_tags[0]]
-      subject.instance_variable_set(:@options, options)
-
-      allow( subject ).to receive( :path )
-      expect( subject ).to receive( :skip_test )
-      subject.tag(*test_tags)
-    end
-
-    it 'runs the test if none of the excluded tags are included in this test' do
-      @tag_excludes = ['pants_on_head', 'jayjay_jayjay', 'mo']
-      test_tags     = ['pants_at_head', 'jayj00_jayjay', 'motly_crew']
-      subject.instance_variable_set(:@options, options)
-
-      allow( subject ).to receive( :path )
-      expect( subject ).to receive( :skip_test ).never
-      subject.tag(*test_tags)
-    end
-
-  end
-end
-
-describe Beaker::DSL::Structure::PlatformTagConfiner do
-  let ( :confines_array ) { @confines_array || [] }
-  let ( :confiner ) {
-    Beaker::DSL::Structure::PlatformTagConfiner.new( confines_array )
-  }
-
-  describe '#initialize' do
-    it 'transforms one entry' do
-      platform_regex = /^ubuntu$/
-      tag_reason_hash = {
-        'tag1' => 'reason1',
-        'tag2' => 'reason2'
-      }
-      @confines_array = [ {
-          :platform => platform_regex,
-          :tag_reason_hash => tag_reason_hash
-        }
-      ]
-
-      internal_hash = confiner.instance_variable_get( :@tag_confine_details_hash )
-      expect( internal_hash.keys() ).to include( 'tag1' )
-      expect( internal_hash.keys() ).to include( 'tag2' )
-      expect( internal_hash.keys().length() ).to be === 2
-
-      tag_reason_hash.each do |tag, reason|
-        tag_array = internal_hash[tag]
-        expect( tag_array.length() ).to be === 1
-        tag_hash = tag_array[0]
-        expect( tag_hash[:platform_regex] ).to eql( platform_regex )
-        expect( tag_hash[:log_message] ).to match( /#{reason}/ )
-        expect( tag_hash[:type] ).to be === :except
-      end
-    end
-
-    it 'deals with the same tag being used on multiple platforms correctly' do
-      @confines_array = [
-        {
-          :platform => /^el-/,
-          :tag_reason_hash => {
-            'tag1' => 'reason el 1',
-            'tag2' => 'reason2'
-          }
-        }, {
-          :platform => /^cisco-/,
-          :tag_reason_hash => {
-            'tag1' => 'reason cisco 1',
-            'tag3' => 'reason3'
-          }
-        }
-      ]
-
-      internal_hash = confiner.instance_variable_get( :@tag_confine_details_hash )
-      expect( internal_hash.keys() ).to include( 'tag1' )
-      expect( internal_hash.keys() ).to include( 'tag2' )
-      expect( internal_hash.keys() ).to include( 'tag3' )
-      expect( internal_hash.keys().length() ).to be === 3
-
-      shared_tag_array = internal_hash['tag1']
-      expect( shared_tag_array.length() ).to be === 2
-
-      platform_el_found = false
-      platform_cisco_found = false
-      shared_tag_array.each do |confine_details|
-        case confine_details[:log_message]
-        when /\ el\ 1/
-          platform_el_found = true
-          platform_to_match = /^el-/
-          reason_to_match = /reason\ el\ 1/
-        when /\ cisco\ 1/
-          platform_cisco_found = true
-          platform_to_match = /^cisco-/
-          reason_to_match = /reason\ cisco\ 1/
-        else
-          log_msg = "unexpected log message for confine_details: "
-          log_msg << confine_details[:log_message]
-          fail( log_msg )
-        end
-
-        expect( confine_details[:platform_regex] ).to eql( platform_to_match )
-        expect( confine_details[:log_message] ).to match( reason_to_match )
-      end
-      expect( platform_el_found ).to be === true
-      expect( platform_cisco_found ).to be === true
-    end
-  end
-
-  describe '#confine_details' do
-    it 'returns an empty array if no tags match' do
-      fake_confine_details_hash = { 'tag1' => [ {:type => 1}, {:type => 2} ]}
-      confiner.instance_variable_set(
-        :@tag_confine_details_hash, fake_confine_details_hash
-      )
-      expect( confiner.confine_details( [ 'tag2', 'tag3' ] ) ).to be === []
-    end
-
-    context 'descriminates on tag name' do
-      fake_confine_details_hash = {
-        'tag0' => [ 10, 20, 30, 40 ],
-        'tag1' => [ 41, 51, 61, 71 ],
-        'tag2' => [ 22, 32, 42, 52 ],
-        'tag3' => [ 63, 73, 83, 93 ],
-        'tag4' => [ 34, 44, 54, 64 ],
-      }
-
-      key_combos_to_test = fake_confine_details_hash.keys.map { |key| [key] }
-      key_combos_to_test << [ 'tag0', 'tag2' ]
-      key_combos_to_test << [ 'tag1', 'tag4' ]
-      key_combos_to_test << [ 'tag2', 'tag3', 'tag4' ]
-      key_combos_to_test << fake_confine_details_hash.keys()
-
-      before :each do
-        confiner.instance_variable_set(
-          :@tag_confine_details_hash, fake_confine_details_hash
-        )
-      end
-
-      key_combos_to_test.each do |key_combo_to_have|
-        it "selects key(s) #{key_combo_to_have} from #{fake_confine_details_hash.keys}" do
-          haves = []
-          key_combo_to_have.each do |key_to_have|
-            haves += fake_confine_details_hash[key_to_have]
-          end
-          keys_not_to_have = fake_confine_details_hash.keys.reject { |key_trial|
-            key_combo_to_have.include?( key_trial )
-          }
-          have_nots = []
-          keys_not_to_have.each do |key_not_to_have|
-            have_nots += fake_confine_details_hash[key_not_to_have]
-          end
-
-          details = confiner.confine_details( key_combo_to_have )
-          have_nots.each do |confine_details|
-            expect( details ).to_not include( confine_details )
-          end
-          haves.each do |confine_details|
-            expect( details ).to     include( confine_details )
-          end
-        end
-      end
-    end
-  end
-end
+end