beaker 4.40.2 → 5.0.0

data/spec/beaker/options/subcommand_options_parser_spec.rb

@@ -3,30 +3,30 @@ require 'spec_helper'
 module Beaker
   module Options
     describe '#parse_subcommand_options' do
-      let(:home_options_file_path) {ENV['HOME']+'/.beaker/subcommand_options.yaml'}
+      let(:home_options_file_path) { ENV.fetch('HOME', nil) + '/.beaker/subcommand_options.yaml' }
       let(:parser_mod) { Beaker::Options::SubcommandOptionsParser }
-      let( :parser ) {parser_mod.parse_subcommand_options(argv, options_file)}
-      let( :file_parser ){parser_mod.parse_options_file({})}
-      let( :argv ) {[]}
-      let( :options_file ) {""}
+      let(:parser) { parser_mod.parse_subcommand_options(argv, options_file) }
+      let(:file_parser) { parser_mod.parse_options_file({}) }
+      let(:argv) { [] }
+      let(:options_file) { "" }
 
       it 'returns an empty OptionsHash if not executing a subcommand' do
-        expect(parser).to be_kind_of(OptionsHash)
+        expect(parser).to be_a(OptionsHash)
         expect(parser).to be_empty
       end
 
       describe 'when the subcommand is init' do
-        let( :argv ) {['init']}
+        let(:argv) { ['init'] }
 
         it 'returns an empty OptionsHash' do
-          expect(parser).to be_kind_of(OptionsHash)
+          expect(parser).to be_a(OptionsHash)
           expect(parser).to be_empty
         end
       end
 
       describe 'when the subcommand is not init' do
-        let( :argv ) {['provision']}
-        let( :options_file ) {home_options_file_path}
+        let(:argv) { ['provision'] }
+        let(:options_file) { home_options_file_path }
 
         it 'calls parse_options_file with subcommand options file when home_dir is false' do
           allow(parser_mod).to receive(:execute_subcommand?).with('provision').and_return true
@@ -41,14 +41,13 @@ module Beaker
         it 'checks for file existence and loads the YAML file' do
           allow(File).to receive(:exist?).and_return true
           allow(YAML).to receive(:load_file).and_return({})
-          expect(file_parser).to be_kind_of(Hash)
-          expect(file_parser).not_to be_kind_of(OptionsHash)
+          expect(file_parser).to be_a(Hash)
+          expect(file_parser).not_to be_a(OptionsHash)
         end
 
-
         it 'returns an empty options hash when file does not exist' do
           allow(File).to receive(:exist?).and_return false
-          expect(parser).to be_kind_of(OptionsHash)
+          expect(parser).to be_a(OptionsHash)
           expect(parser).to be_empty
         end
       end

data/spec/beaker/options/validator_spec.rb

@@ -2,13 +2,12 @@ require 'spec_helper'
 
 module Beaker
   module Options
-
     describe Validator do
       let(:validator) { described_class.new }
 
       describe '#check_yaml_file' do
-        let(:bad_yaml_path) { File.join(File.expand_path(File.dirname(__FILE__)), 'data', 'badyaml.cfg') }
-        let(:yaml_path) { File.join(File.expand_path(File.dirname(__FILE__)), 'data', 'hosts.cfg') }
+        let(:bad_yaml_path) { File.join(File.expand_path(__dir__), 'data', 'badyaml.cfg') }
+        let(:yaml_path) { File.join(File.expand_path(__dir__), 'data', 'hosts.cfg') }
 
         before do
           FakeFS.deactivate!
@@ -98,18 +97,18 @@ module Beaker
           tag_includes = %w(can tommies should_error potatoes plant)
           tag_excludes = %w(joey long_running pants should_error)
 
-          expect {
+          expect do
             validator.validate_test_tags(tag_includes, [], tag_excludes)
-          }.to raise_error(ArgumentError)
+          end.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 {
+          expect do
             validator.validate_test_tags(tag_includes, [], tag_excludes)
-          }.not_to raise_error
+          end.not_to raise_error
         end
 
         it 'raises an error if AND and OR are both used' do
@@ -118,9 +117,9 @@ module Beaker
           tag_and = %w(square)
           tag_or  = %w(circle)
 
-          expect {
+          expect do
             validator.validate_test_tags(tag_and, tag_or, [])
-          }.to raise_error(ArgumentError)
+          end.to raise_error(ArgumentError)
         end
       end
 
@@ -178,8 +177,8 @@ module Beaker
       end
 
       describe '#validate_platform' do
-        let(:valid_platform) { {'platform' => 'test1'} }
-        let(:blank_platform) { {'platform' => ''} }
+        let(:valid_platform) { { 'platform' => 'test1' } }
+        let(:blank_platform) { { 'platform' => '' } }
 
         it 'does not throw an error when host has a platform' do
           expect { validator.validate_platform(valid_platform, 'vm1') }.not_to raise_error

data/spec/beaker/perf_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Beaker
   describe Perf do
-
     context "When a Perf object is created" do
       before do
         @options = make_opts
@@ -16,42 +15,41 @@ module Beaker
       end
 
       it 'creates a new Perf object' do
-        hosts = Array.new
-        options = Hash.new
+        hosts = []
+        options = {}
         options[:log_level] = :debug
         my_logger = Beaker::Logger.new(options)
         options[:logger] = my_logger
-        perf = described_class.new( hosts, options )
-        expect( perf ).to be_a_kind_of described_class
+        perf = described_class.new(hosts, options)
+        expect(perf).to be_a described_class
       end
 
-
       it 'creates a new Perf object with a single host' do
-        hosts = [ make_host("myHost", @options) ]
+        hosts = [make_host("myHost", @options)]
         hosts.each { |host| host['platform'] = "centos-6-x86_64" }
         @my_logger.remove_destination(STDOUT)
-        perf = described_class.new( hosts, @options )
-        expect( perf ).to be_a_kind_of described_class
+        perf = described_class.new(hosts, @options)
+        expect(perf).to be_a described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost/)
       end
 
       it 'creates a new Perf object with multiple hosts' do
-        hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options) ]
+        hosts = [make_host("myHost", @options), make_host("myOtherHost", @options)]
         hosts.each { |host| host['platform'] = "centos-6-x86_64" }
         @my_logger.remove_destination(STDOUT)
-        perf = described_class.new( hosts, @options )
-        expect( perf ).to be_a_kind_of described_class
+        perf = described_class.new(hosts, @options)
+        expect(perf).to be_a described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost*\nSetup perf on host: myOtherHost/)
       end
 
       it 'creates a new Perf object with multiple hosts, SLES' do
-        hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options), make_host("myThirdHost", @options) ]
+        hosts = [make_host("myHost", @options), make_host("myOtherHost", @options), make_host("myThirdHost", @options)]
         hosts[0]['platform'] = "centos-6-x86_64"
         hosts[1]['platform'] = "sles-11-x86_64"
         hosts[2]['platform'] = "opensuse-15-x86_64"
         @my_logger.remove_destination(STDOUT)
-        perf = described_class.new( hosts, @options )
-        expect( perf ).to be_a_kind_of described_class
+        perf = described_class.new(hosts, @options)
+        expect(perf).to be_a described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost\nSetup perf on host: myOtherHost/)
       end
     end
@@ -62,7 +60,7 @@ module Beaker
         @options[:collect_perf_data] = 'normal'
         @options[:log_level] = :debug
         @options[:color] = false
-        @hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options) ]
+        @hosts = [make_host("myHost", @options), make_host("myOtherHost", @options)]
         @my_io = StringIO.new
         @my_logger = Beaker::Logger.new(@options)
         @my_logger.add_destination(@my_io)
@@ -72,8 +70,8 @@ module Beaker
       it "Does the Right Thing on Linux hosts" do
         @hosts[0]['platform'] = "centos-6-x86_64"
         @my_logger.remove_destination(STDOUT)
-        perf = described_class.new( @hosts, @options )
-        expect( perf ).to be_a_kind_of described_class
+        perf = described_class.new(@hosts, @options)
+        expect(perf).to be_a described_class
         perf.print_perf_info
         expect(@my_io.string).to match(/Setup perf on host: myHost\nSetup perf on host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost\nGetting perf data for host: myHost\nGetting perf data for host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost/)
       end
@@ -81,12 +79,11 @@ module Beaker
       it "Does the Right Thing on non-Linux hosts" do
         @hosts[0]['platform'] = "windows"
         @my_logger.remove_destination(STDOUT)
-        perf = described_class.new( @hosts, @options )
-        expect( perf ).to be_a_kind_of described_class
+        perf = described_class.new(@hosts, @options)
+        expect(perf).to be_a described_class
         perf.print_perf_info
         expect(@my_io.string).to match(/Setup perf on host: myHost\nPerf \(sysstat\) not supported on host: myHost\nSetup perf on host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost\nGetting perf data for host: myHost\nPerf \(sysstat\) not supported on host: myHost\nGetting perf data for host: myOtherHost\nPerf \(sysstat\) not supported on host: myOtherHost/)
       end
     end
-
   end
 end

data/spec/beaker/platform_spec.rb

@@ -2,43 +2,37 @@ require 'spec_helper'
 
 module Beaker
   describe Platform do
-
-    let( :logger )    { double( 'logger' ) }
-    let( :platform )  { described_class.new(@name) }
+    let(:logger)    { double('logger') }
+    let(:platform)  { described_class.new(@name) }
 
     context 'initialize' do
-
       describe "recognizes valid platforms" do
-
         it "accepts correctly formatted platform values" do
           @name = 'oracle-version-arch'
-          expect{ platform }.not_to raise_error
+          expect { platform }.not_to raise_error
         end
 
         it "rejects non-supported osfamilies" do
           @name = 'amazon6-version-arch'
-          expect{ platform }.to raise_error(ArgumentError)
+          expect { platform }.to raise_error(ArgumentError)
         end
 
         it "rejects platforms without version/arch" do
           @name = 'ubuntu-5'
-          expect{ platform }.to raise_error(ArgumentError)
+          expect { platform }.to raise_error(ArgumentError)
         end
 
         it "rejects platforms that do not have osfamily at start of string" do
           @name = 'o3l-r5-u6-x86'
-          expect{ platform }.to raise_error(ArgumentError)
+          expect { platform }.to raise_error(ArgumentError)
         end
-
       end
 
       describe "if platform does not have codename" do
-
         it "sets codename to nil" do
           @name = "centos-6.5-x86_64"
           expect(platform.codename).to be_nil
         end
-
       end
 
       describe "platforms with version and codename" do
@@ -57,96 +51,91 @@ module Beaker
     end
 
     context 'to_array' do
-
       it "converts Beaker::Platform object to array of its attribues" do
         @name = 'debian-7-somethingsomething'
-        expect( platform.to_array ).to be === ['debian', '7', 'somethingsomething', 'wheezy']
+        expect(platform.to_array).to be === %w[debian 7 somethingsomething wheezy]
       end
-
     end
 
     context 'with_version_codename' do
-
       it "can convert debian-11-xxx to debian-bullseye-xxx" do
         @name = 'debian-11-xxx'
-        expect( platform.with_version_codename ).to be === 'debian-bullseye-xxx'
+        expect(platform.with_version_codename).to be === 'debian-bullseye-xxx'
       end
 
       it "can convert debian-7-xxx to debian-wheezy-xxx" do
         @name = 'debian-7-xxx'
-        expect( platform.with_version_codename ).to be === 'debian-wheezy-xxx'
+        expect(platform.with_version_codename).to be === 'debian-wheezy-xxx'
       end
 
       it "can convert debian-6-xxx to debian-squeeze-xxx" do
         @name = 'debian-6-xxx'
-        expect( platform.with_version_codename ).to be === 'debian-squeeze-xxx'
+        expect(platform.with_version_codename).to be === 'debian-squeeze-xxx'
       end
 
       it "can convert ubuntu-2204-xxx to ubuntu-jammy-xxx" do
         @name = 'ubuntu-2204-xxx'
-	expect( platform.with_version_codename ).to be === 'ubuntu-jammy-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-jammy-xxx'
       end
 
       it "can convert ubuntu-2004-xxx to ubuntu-focal-xxx" do
         @name = 'ubuntu-2004-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-focal-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-focal-xxx'
       end
 
       it "can convert ubuntu-1604-xxx to ubuntu-xenial-xxx" do
         @name = 'ubuntu-1604-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-xenial-xxx'
-
+        expect(platform.with_version_codename).to be === 'ubuntu-xenial-xxx'
       end
 
       it "can convert ubuntu-1310-xxx to ubuntu-saucy-xxx" do
         @name = 'ubuntu-1310-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-saucy-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-saucy-xxx'
       end
 
       it "can convert ubuntu-12.10-xxx to ubuntu-quantal-xxx" do
         @name = 'ubuntu-12.10-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-quantal-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-quantal-xxx'
       end
 
       it "can convert ubuntu-10.04-xxx to ubuntu-lucid-xxx" do
         @name = 'ubuntu-10.04-xxx'
-        expect( platform.with_version_codename ).to be === 'ubuntu-lucid-xxx'
+        expect(platform.with_version_codename).to be === 'ubuntu-lucid-xxx'
       end
 
-      ['centos','redhat'].each do |p|
+      %w[centos redhat].each do |p|
         it "leaves #{p}-7-xxx alone" do
           @name = "#{p}-7-xxx"
-          expect( platform.with_version_codename ).to be === "#{p}-7-xxx"
+          expect(platform.with_version_codename).to be === "#{p}-7-xxx"
         end
       end
     end
 
     context 'with_version_number' do
-
       it "can convert debian-wheezy-xxx to debian-7-xxx" do
         @name = 'debian-wheezy-xxx'
-        expect( platform.with_version_number ).to be === 'debian-7-xxx'
+        expect(platform.with_version_number).to be === 'debian-7-xxx'
       end
 
       it "can convert debian-squeeze-xxx to debian-6-xxx" do
         @name = 'debian-squeeze-xxx'
-        expect( platform.with_version_number ).to be === 'debian-6-xxx'
+        expect(platform.with_version_number).to be === 'debian-6-xxx'
       end
 
       it "can convert ubuntu-saucy-xxx to ubuntu-1310-xxx" do
         @name = 'ubuntu-saucy-xxx'
-        expect( platform.with_version_number ).to be === 'ubuntu-1310-xxx'
+        expect(platform.with_version_number).to be === 'ubuntu-1310-xxx'
       end
 
       it "can convert ubuntu-quantal-xxx to ubuntu-1210-xxx" do
         @name = 'ubuntu-quantal-xxx'
-        expect( platform.with_version_number ).to be === 'ubuntu-1210-xxx'
+        expect(platform.with_version_number).to be === 'ubuntu-1210-xxx'
       end
 
-      ['centos','redhat'].each do |p|
+      %w[centos redhat].each do |p|
         it "leaves #{p}-7-xxx alone" do
           @name = "#{p}-7-xxx"
-          expect( platform.with_version_number ).to be === "#{p}-7-xxx"
+          expect(platform.with_version_number).to be === "#{p}-7-xxx"
         end
       end
     end
@@ -165,7 +154,7 @@ module Beaker
         end
       end
 
-      [:variant, :arch, :version, :codename].each do |field|
+      %i[variant arch version codename].each do |field|
         it "deserializes the '#{field}' field" do
           expect(round_tripped.send(field)).to eq platform.send(field)
         end

data/spec/beaker/shared/error_handler_spec.rb

@@ -3,38 +3,29 @@ require 'spec_helper'
 module Beaker
   module Shared
     describe ErrorHandler do
-
-      let( :backtrace ) { "I'm the backtrace\nYes I am!\nI have important information" }
-      let( :logger )    { double( 'logger' ) }
+      let(:backtrace) { "I'm the backtrace\nYes I am!\nI have important information" }
+      let(:logger)    { double('logger') }
 
       before do
-        allow( logger ).to receive( :error ).and_return( true )
-        allow( logger ).to receive( :pretty_backtrace ).and_return( backtrace )
-
+        allow(logger).to receive(:error).and_return(true)
+        allow(logger).to receive(:pretty_backtrace).and_return(backtrace)
       end
 
       context 'report_and_raise' do
-
         it "records the backtrace of the exception to the logger" do
           ex = Exception.new("ArgumentError")
-          allow( ex ).to receive( :backtrace ).and_return(backtrace)
+          allow(ex).to receive(:backtrace).and_return(backtrace)
           mesg = "I'm the extra message"
 
           backtrace.each_line do |line|
-            expect( logger ).to receive( :error ).with(line)
+            expect(logger).to receive(:error).with(line)
           end
 
-          expect( subject ).to receive( :raise ).once
+          expect(subject).to receive(:raise).once
 
           subject.report_and_raise(logger, ex, mesg)
-
         end
-
-
-
       end
-
     end
-
   end
 end

data/spec/beaker/shared/fog_credentials_spec.rb

@@ -5,94 +5,94 @@ module Beaker
     describe FogCredentials do
       describe "#get_fog_credentials" do
         it 'raises ArgumentError when fog file is missing' do
-          expect{ get_fog_credentials( '/path/that/does/not/exist/.fog' ) }.to raise_error( ArgumentError )
+          expect { get_fog_credentials('/path/that/does/not/exist/.fog') }.to raise_error(ArgumentError)
         end
 
         it 'raises ArgumentError when fog file is empty' do
-          expect( File ).to receive( :open ).and_return("")
+          expect(File).to receive(:open).and_return("")
 
-          expect{ get_fog_credentials( '/path/that/does/not/exist/.fog') }.to raise_error( ArgumentError )
+          expect { get_fog_credentials('/path/that/does/not/exist/.fog') }.to raise_error(ArgumentError)
         end
 
         it 'raises ArgumentError when fog file does not contain "default" section and no section is specified' do
           data = { :some => { :other => :data } }
 
-          expect( YAML ).to receive( :load_file ) { data }
+          expect(YAML).to receive(:load_file) { data }
 
-          expect{ get_fog_credentials( '/path/that/does/not/exist/.fog' ) }.to raise_error( ArgumentError )
+          expect { get_fog_credentials('/path/that/does/not/exist/.fog') }.to raise_error(ArgumentError)
         end
 
         it 'raises ArgumentError when fog file does not contain another section passed by argument' do
           data = { :some => { :other => :data } }
 
-          expect( YAML ).to receive( :load_file ) { data }
+          expect(YAML).to receive(:load_file) { data }
 
-          expect{ get_fog_credentials( '/path/that/does/not/exist/.fog', :other_credential ) }.to raise_error( ArgumentError )
+          expect { get_fog_credentials('/path/that/does/not/exist/.fog', :other_credential) }.to raise_error(ArgumentError)
         end
 
         it 'raises ArgumentError when there are formatting errors in the fog file' do
           data = { "'default'" => { :vmpooler_token => "b2wl8prqe6ddoii70md" } }
 
-          expect( YAML ).to receive( :load_file ) { data }
+          expect(YAML).to receive(:load_file) { data }
 
-          expect{ get_fog_credentials( '/path/that/does/not/exist/.fog' ) }.to raise_error( ArgumentError )
+          expect { get_fog_credentials('/path/that/does/not/exist/.fog') }.to raise_error(ArgumentError)
         end
 
         it 'raises ArgumentError when there are syntax errors in the fog file' do
           data = ";default;\n  :vmpooler_token: z2wl8prqe0ddoii707d"
 
-          allow( File ).to receive( :open ).and_yield( StringIO.new( data ) )
+          allow(File).to receive(:open).and_yield(StringIO.new(data))
 
-          expect{ get_fog_credentials( '/path/that/does/not/exist/.fog' ) }.to raise_error( ArgumentError, /Psych::SyntaxError/ )
+          expect { get_fog_credentials('/path/that/does/not/exist/.fog') }.to raise_error(ArgumentError, /Psych::SyntaxError/)
         end
 
         it 'returns the named credential section' do
           data = {
-            :default          => { :vmpooler_token => "wrong_token"},
-            :other_credential => { :vmpooler_token => "correct_token" }
+            :default => { :vmpooler_token => "wrong_token" },
+            :other_credential => { :vmpooler_token => "correct_token" },
           }
 
-          expect( YAML ).to receive( :load_file ) { data }
+          expect(YAML).to receive(:load_file) { data }
 
-          expect( get_fog_credentials( '/path/that/does/not/exist/.fog', :other_credential )[:vmpooler_token] ).to eq( "correct_token" )
+          expect(get_fog_credentials('/path/that/does/not/exist/.fog', :other_credential)[:vmpooler_token]).to eq("correct_token")
         end
 
         it 'returns the named credential section from ENV["FOG_CREDENTIAL"]' do
           ENV['FOG_CREDENTIAL'] = 'other_credential'
           data = {
-            :default         => { :vmpooler_token => "wrong_token"},
-            :other_credential => { :vmpooler_token => "correct_token" }
+            :default => { :vmpooler_token => "wrong_token" },
+            :other_credential => { :vmpooler_token => "correct_token" },
           }
 
-          expect( YAML ).to receive( :load_file ) { data }
+          expect(YAML).to receive(:load_file) { data }
 
-          expect( get_fog_credentials( '/path/that/does/not/exist/.fog' )[:vmpooler_token] ).to eq( "correct_token" )
-          ENV.delete( 'FOG_CREDENTIAL' )
+          expect(get_fog_credentials('/path/that/does/not/exist/.fog')[:vmpooler_token]).to eq("correct_token")
+          ENV.delete('FOG_CREDENTIAL')
         end
 
         it 'returns the named credential section from ENV["FOG_CREDENTIAL"] even when an argument is provided' do
           ENV['FOG_CREDENTIAL'] = 'other_credential'
           data = {
-            :default         => { :vmpooler_token => "wrong_token"},
-            :other_credential => { :vmpooler_token => "correct_token" }
+            :default => { :vmpooler_token => "wrong_token" },
+            :other_credential => { :vmpooler_token => "correct_token" },
           }
 
-          expect( YAML ).to receive( :load_file ) { data }
+          expect(YAML).to receive(:load_file) { data }
 
-          expect( get_fog_credentials( '/path/that/does/not/exist/.fog', :default )[:vmpooler_token] ).to eq( "correct_token" )
-          ENV.delete( 'FOG_CREDENTIAL' )
+          expect(get_fog_credentials('/path/that/does/not/exist/.fog', :default)[:vmpooler_token]).to eq("correct_token")
+          ENV.delete('FOG_CREDENTIAL')
         end
 
         it 'returns the named credential section from ENV["FOG_RC"] path' do
           ENV['FOG_RC'] = '/some/other/path/to/.fog'
           data = {
-            :default         => { :vmpooler_token => "correct_token"},
-            :other_credential => { :vmpooler_token => "wrong_token" }
+            :default => { :vmpooler_token => "correct_token" },
+            :other_credential => { :vmpooler_token => "wrong_token" },
           }
 
-          expect( YAML ).to receive( :load_file ).with( '/some/other/path/to/.fog' ) { data }
+          expect(YAML).to receive(:load_file).with('/some/other/path/to/.fog') { data }
 
-          expect( get_fog_credentials( '/path/that/does/not/exist/.fog', :default )[:vmpooler_token] ).to eq( "correct_token" )
+          expect(get_fog_credentials('/path/that/does/not/exist/.fog', :default)[:vmpooler_token]).to eq("correct_token")
         end
       end
     end