beaker 3.12.0 → 3.13.0

data/spec/beaker/dsl/test_tagging_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+
+class ClassMixedWithDSLStructure
+  include Beaker::DSL::TestTagging
+  include Beaker::DSL::Helpers::TestHelpers
+end
+
+describe ClassMixedWithDSLStructure do
+  include Beaker::DSL::Assertions
+
+  let (:logger) { double }
+  let (:metadata) { @metadata ||= {} }
+
+  before :each do
+    allow( subject ).to receive(:metadata).and_return(metadata)
+  end
+
+  describe '#tag' do
+    let ( :test_tag_and     ) { @test_tag_and     || [] }
+    let ( :test_tag_or      ) { @test_tag_or      || [] }
+    let ( :test_tag_exclude ) { @test_tag_exclude || [] }
+    let ( :options          ) {
+      opts                    = Beaker::Options::OptionsHash.new
+      opts[:test_tag_and]     = test_tag_and
+      opts[:test_tag_or]      = test_tag_or
+      opts[:test_tag_exclude] = test_tag_exclude
+      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']
+      @test_tag_and = 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
+      @test_tag_and = ['pants_on_head', 'jayjay_jayjay', 'mo']
+      test_tags     = @test_tag_and.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']
+      @test_tag_exclude = [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 'skips the test if an and-included & excluded tag are in this test' do
+      test_tags         = ['ports', 'jay_john_mary', 'mog_the_dog']
+      @test_tag_and     = [test_tags[1]]
+      @test_tag_exclude = [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
+      @test_tag_exclude = ['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
+
+    it 'skips the test if none of the OR tags are included in this test' do
+      test_tags = ['portmanteau', 'foolios']
+      @test_tag_or = ['fish', 'crayons', 'parkas']
+      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 only one of the OR tags are included in this test' do
+      test_tags = ['portmanteau', 'foolios']
+      @test_tag_or = ['foolios', 'crayons', 'parkas']
+      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 an or-included & excluded tag are included in this test' do
+      test_tags         = ['ports', 'jay_john_mary', 'mog_the_dog']
+      @test_tag_or      = [test_tags[1]]
+      @test_tag_exclude = [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
+  end
+end
+
+describe Beaker::DSL::TestTagging::PlatformTagConfiner do
+  let ( :confines_array ) { @confines_array || [] }
+  let ( :confiner ) {
+    Beaker::DSL::TestTagging::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

data/spec/beaker/host/cisco_spec.rb

@@ -107,8 +107,8 @@ module Cisco
 
         it 'turns env maps into paired strings correctly' do
           @options = { :user => 'root' }
-          env_map = { 'var1' => 'ans1', 'var2' => 'ans2' }
-          answer_correct = 'source /etc/profile; export VAR1="ans1" VAR2="ans2";'
+          env_map = { 'var1' => 'ans1', 'VAR2' => 'ans2' }
+          answer_correct = 'source /etc/profile; export var1="ans1" VAR1="ans1" VAR2="ans2";'
           answer_test = host.environment_string( env_map )
           expect( answer_test ).to be === answer_correct
         end
@@ -141,8 +141,8 @@ module Cisco
 
         it 'turns env maps into paired strings correctly' do
           @options = { :user => 'root' }
-          env_map = { 'var1' => 'ans1', 'var2' => 'ans2' }
-          answer_correct = 'source /etc/profile; env VAR1="ans1" VAR2="ans2"'
+          env_map = { 'VAR1' => 'ans1', 'var2' => 'ans2' }
+          answer_correct = 'source /etc/profile; env VAR1="ans1" var2="ans2" VAR2="ans2"'
           answer_test = host.environment_string( env_map )
           expect( answer_test ).to be === answer_correct
         end

data/spec/beaker/host/unix/exec_spec.rb

@@ -60,8 +60,8 @@ module Beaker
       end
 
       it 'takes an env hash with var_name/value pairs' do
-        expect( instance.environment_string( {:HOME => '/'} ) ).
-          to be == "env HOME=\"/\""
+        expect( instance.environment_string( {:HOME => '/', :http_proxy => 'http://foo'} ) ).
+          to be == 'env HOME="/" http_proxy="http://foo" HTTP_PROXY="http://foo"'
       end
 
       it 'takes an env hash with var_name/value[Array] pairs' do

data/spec/beaker/host_prebuilt_steps_spec.rb

@@ -349,7 +349,7 @@ describe Beaker do
 
     it "can sync keys on a non-solaris host" do
 
-      expect( Beaker::Command ).to receive( :new ).with( sync_cmd % "env PATH=/usr/gnu/bin:$PATH bash" ).exactly( 3 ).times
+      expect( Beaker::Command ).to receive( :new ).with( sync_cmd % "env PATH=\"/usr/gnu/bin:$PATH\" bash" ).exactly( 3 ).times
 
       subject.sync_root_keys( hosts, options )
 

data/spec/beaker/options/command_line_parser_spec.rb

@@ -6,8 +6,8 @@ module Beaker
 
       let(:parser) {Beaker::Options::CommandLineParser.new}
       let(:test_opts) {["-h", "vcloud.cfg", "--debug", "--tests", "test.rb", "--help"]}
-      let(:full_opts_in)  {["--hosts", "host.cfg",           "--options", "opts_file", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--pre-cleanup", "pre_cleanup.rb", "--no-provision", "--preserve-hosts", "always",   "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath",     "-m", "module",         "-q",    "--dry-run",       "--no-ntp",    "--repo-proxy",    "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast",  "--no-color", "--no-color-host-output",  "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128",    "--collect-perf-data",    "--parse-only",    "--validate", "--timeout", "40", "--log-prefix", "pants",      "--configure",         "--tag", "1,2,3", "--exclude-tag", "4,5,6",        "--xml-time-order"]}
-      let(:full_opts_out) {{:hosts_file=>"anotherfile.cfg",:options_file=>"opts_file",  :helper => "path_to_helper",  :load_path => "load_path",  :tests => "test1.rb,test2.rb,test3.rb",  :pre_suite => "pre_suite.rb",  :post_suite => "post_suite.rb", :pre_cleanup => "pre_cleanup.rb", :provision=>false, :preserve_hosts => "always", :root_keys=>true, :keyfile => "../.ssh/id_rsa",  :install => "gitrepopath", :modules=>"module", :quiet=>true, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true,                                 :fail_mode => "fast", :color=>false, :color_host_output=>false, :beaker_version_print=>true,  :log_level => "info",  :package_proxy => "http://192.168.100.1:3128", :collect_perf_data=>"normal", :parse_only=>true, :validate=>true,  :timeout => "40",  :log_prefix => "pants", :configure => true, :tag_includes => "1,2,3", :tag_excludes => "4,5,6", :xml_time_enabled => true}}
+      let(:full_opts_in)  {["--hosts", "host.cfg",           "--options", "opts_file", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--pre-cleanup", "pre_cleanup.rb", "--no-provision", "--preserve-hosts", "always",   "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath",     "-m", "module",         "-q",    "--dry-run",       "--no-ntp",    "--repo-proxy",    "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast",  "--no-color", "--no-color-host-output",                 "--version", "--log-level", "info", "--package-proxy", "http://192.168.100.1:3128",        "--collect-perf-data",    "--parse-only",    "--validate", "--timeout", "40", "--log-prefix", "pants",      "--configure", "--test-tag-and", "1,2,3", "--test-tag-or", "4,5,6", "--test-tag-exclude", "7,8,9",        "--xml-time-order"]}
+      let(:full_opts_out) {{:hosts_file=>"anotherfile.cfg",:options_file=>"opts_file",  :helper => "path_to_helper",  :load_path => "load_path",  :tests => "test1.rb,test2.rb,test3.rb",  :pre_suite => "pre_suite.rb",  :post_suite => "post_suite.rb", :pre_cleanup => "pre_cleanup.rb", :provision=>false, :preserve_hosts => "always", :root_keys=>true, :keyfile => "../.ssh/id_rsa",  :install => "gitrepopath", :modules=>"module", :quiet=>true, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true,                                 :fail_mode => "fast", :color=>false, :color_host_output=>false, :beaker_version_print=>true,  :log_level => "info",  :package_proxy => "http://192.168.100.1:3128", :collect_perf_data=>"normal", :parse_only=>true, :validate=>true,  :timeout => "40",  :log_prefix => "pants", :configure => true,  :test_tag_and => "1,2,3",  :test_tag_or => "4,5,6",  :test_tag_exclude => "7,8,9", :xml_time_enabled => true}}
       let(:validate_true)  {["--validate"]}
       let(:validate_false) {["--no-validate"]}
       let(:configure_true)  {['--configure']}

data/spec/beaker/options/parser_spec.rb

@@ -479,51 +479,60 @@ module Beaker
       end
 
       describe '#normalize_tags!' 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
+        let (:test_tag_and      ) { @test_tag_and     || [] }
+        let (:test_tag_or       ) { @test_tag_or      || [] }
+        let (:test_tag_exclude  ) { @test_tag_exclude || [] }
+        let (:options           ) {
+          opts                    = Beaker::Options::OptionsHash.new
+          opts[:test_tag_and]     = test_tag_and
+          opts[:test_tag_or]      = test_tag_or
+          opts[:test_tag_exclude] = test_tag_exclude
           opts
         }
 
         it 'does not error if no tags overlap' do
-          @tag_includes = 'can,tommies,potatoes,plant'
-          @tag_excludes = 'joey,long_running,pants'
+          @test_tag_and     = 'can,tommies,potatoes,plant'
+          @test_tag_or      = 'juicy,zoomba,plantation'
+          @test_tag_exclude = 'joey,long_running,pants'
           parser.instance_variable_set(:@options, options)
 
-          expect { parser.normalize_tags! }.not_to raise_error
+          expect { parser.normalize_test_tags! }.not_to raise_error
         end
 
         it 'splits the basic case correctly' do
-          @tag_includes = 'can,tommies,potatoes,plant'
-          @tag_excludes = 'joey,long_running,pants'
+          @test_tag_and     = 'can,tommies,potatoes,plant'
+          @test_tag_or      = 'johnny,wordsmith,zebra'
+          @test_tag_exclude = 'joey,long_running,pants'
           parser.instance_variable_set(:@options, options)
 
-          parser.normalize_tags!
-          expect(options[:tag_includes]).to be === ['can', 'tommies', 'potatoes', 'plant']
-          expect(options[:tag_excludes]).to be === ['joey', 'long_running', 'pants']
+          parser.normalize_test_tags!
+          expect(options[:test_tag_and]    ).to be === ['can', 'tommies', 'potatoes', 'plant']
+          expect(options[:test_tag_or]     ).to be === ['johnny', 'wordsmith', 'zebra']
+          expect(options[:test_tag_exclude]).to be === ['joey', 'long_running', 'pants']
         end
 
         it 'returns empty arrays for empty strings' do
-          @tag_includes = ''
-          @tag_excludes = ''
+          @test_tag_and     = ''
+          @test_tag_or      = ''
+          @test_tag_exclude = ''
           parser.instance_variable_set(:@options, options)
 
-          parser.normalize_tags!
-          expect(options[:tag_includes]).to be === []
-          expect(options[:tag_excludes]).to be === []
+          parser.normalize_test_tags!
+          expect(options[:test_tag_and]    ).to be === []
+          expect(options[:test_tag_or]     ).to be === []
+          expect(options[:test_tag_exclude]).to be === []
         end
 
         it 'lowercases all tags correctly for later use' do
-          @tag_includes = 'jeRRy_And_tOM,PARka'
-          @tag_excludes = 'lEet_spEAK,pOland'
+          @test_tag_and     = 'jeRRy_And_tOM,PARka'
+          @test_tag_or      = 'clearLy_They,Neva'
+          @test_tag_exclude = 'lEet_spEAK,pOland'
           parser.instance_variable_set(:@options, options)
 
-          parser.normalize_tags!
-          expect(options[:tag_includes]).to be === ['jerry_and_tom', 'parka']
-          expect(options[:tag_excludes]).to be === ['leet_speak', 'poland']
+          parser.normalize_test_tags!
+          expect(options[:test_tag_and]    ).to be === ['jerry_and_tom', 'parka']
+          expect(options[:test_tag_or]     ).to be === ['clearly_they', 'neva']
+          expect(options[:test_tag_exclude]).to be === ['leet_speak', 'poland']
         end
       end
 

data/spec/beaker/options/validator_spec.rb

@@ -93,19 +93,34 @@ module Beaker
         end
       end
 
-      describe '#validate_tags' do
+      describe '#validate_test_tags' do
         it 'does error if tags overlap' do
           tag_includes = %w(can tommies should_error potatoes plant)
           tag_excludes = %w(joey long_running pants should_error)
 
-          expect { validator.validate_tags(tag_includes, tag_excludes) }.to raise_error(ArgumentError)
+          expect {
+            validator.validate_test_tags(tag_includes, [], tag_excludes)
+          }.to raise_error(ArgumentError)
         end
 
         it 'does not raise an error if tags do not overlap' do
           tag_includes = %w(horse dog cat)
           tag_excludes = %w(car truck train)
 
-          expect { validator.validate_tags(tag_includes, tag_excludes) }.to_not raise_error
+          expect {
+            validator.validate_test_tags(tag_includes, [], tag_excludes)
+          }.to_not raise_error
+        end
+
+        it 'raises an error if AND and OR are both used' do
+          # this is because we don't have a way to specify how they
+          # should interact
+          tag_and = %w(square)
+          tag_or  = %w(circle)
+
+          expect {
+            validator.validate_test_tags(tag_and, tag_or, [])
+          }.to raise_error(ArgumentError)
         end
       end