beaker 4.38.1 → 5.0.0

data/spec/beaker/hypervisor/hypervisor_spec.rb

@@ -2,63 +2,62 @@ require 'spec_helper'
 
 module Beaker
   describe Hypervisor do
-    let( :hosts ) { make_hosts( { :platform => 'el-5' } ) }
+    let(:hosts) { make_hosts({ :platform => 'el-5' }) }
 
-    context "#create" do
-      let( :hypervisor ) { Beaker::Hypervisor }
+    describe "#create" do
+      let(:hypervisor) { described_class }
 
       it "includes custom hypervisor and call set_ssh_connection_preference" do
         allow(hypervisor).to receive(:set_ssh_connection_preference).with([], hypervisor)
-        expect{ hypervisor.create('custom_hypervisor', [], make_opts() )}.to raise_error(LoadError, "cannot load such file -- beaker/hypervisor/custom_hypervisor")
+        expect { hypervisor.create('custom_hypervisor', [], make_opts) }.to raise_error(LoadError, "cannot load such file -- beaker/hypervisor/custom_hypervisor")
       end
 
       it "sets ssh connection preference if connection_preference method is not overwritten" do
-        hypervisor.create('none', hosts, make_opts())
-        expect(hosts[0][:ssh_connection_preference]).to eq([:ip,:vmhostname,:hostname])
+        hypervisor.create('none', hosts, make_opts)
+        expect(hosts[0][:ssh_connection_preference]).to eq(%i[ip vmhostname hostname])
       end
 
       it "concats overriding connection_preference array with the default connection_preference" do
-        allow(hypervisor).to receive(:connection_preference).and_return([:my,:invalid,:method_name])
+        allow(hypervisor).to receive(:connection_preference).and_return(%i[my invalid method_name])
         hypervisor.set_ssh_connection_preference(hosts, hypervisor)
-        expect(hosts[0][:ssh_connection_preference]).to eq([:my,:invalid,:method_name,:ip,:vmhostname,:hostname])
+        expect(hosts[0][:ssh_connection_preference]).to eq(%i[my invalid method_name ip vmhostname hostname])
       end
 
       it "removes unique elements from concated array while preserving order of overriding methods" do
-        allow(hypervisor).to receive(:connection_preference).and_return([:my,:ip,:vmhostname,:method_name])
+        allow(hypervisor).to receive(:connection_preference).and_return(%i[my ip vmhostname method_name])
         hypervisor.set_ssh_connection_preference(hosts, hypervisor)
-        expect(hosts[0][:ssh_connection_preference]).to eq([:my,:ip,:vmhostname,:method_name,:hostname])
+        expect(hosts[0][:ssh_connection_preference]).to eq(%i[my ip vmhostname method_name hostname])
       end
 
       it "gives highest precedence to preference specified in host file followed by hypervisor" do
-        hosts[0].options[:ssh_preference] = [:set, :in, :hostfile]
-        hypervisor.create('none', hosts, make_opts())
-        allow(hypervisor).to receive(:connection_preference).and_return([:hypervisor, :pref])
+        hosts[0].options[:ssh_preference] = %i[set in hostfile]
+        hypervisor.create('none', hosts, make_opts)
+        allow(hypervisor).to receive(:connection_preference).and_return(%i[hypervisor pref])
         hypervisor.set_ssh_connection_preference(hosts, hypervisor)
-        expect(hosts[0][:ssh_connection_preference]).to eq([:set, :in, :hostfile, :hypervisor, :pref, :ip, :vmhostname, :hostname])
+        expect(hosts[0][:ssh_connection_preference]).to eq(%i[set in hostfile hypervisor pref ip vmhostname hostname])
       end
-
     end
 
-    context "#configure" do
-      let( :options ) { make_opts.merge({ 'logger' => double().as_null_object }) }
-      let( :hypervisor ) { Beaker::Hypervisor.new( hosts, options ) }
+    describe "#configure" do
+      let(:options) { make_opts.merge({ 'logger' => double.as_null_object }) }
+      let(:hypervisor) { described_class.new(hosts, options) }
 
       context 'if :timesync option set true on host' do
         it 'does call timesync for host' do
           hosts[0].options[:timesync] = true
-          allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :timesync ).once
+          allow(hypervisor).to receive(:set_env)
+          expect(hypervisor).to receive(:timesync).once
           hypervisor.configure
         end
 
         it 'catches signal exceptions and returns stack trace' do
-          logger = double()
+          logger = double
           hosts[0].options[:timesync] = true
-          allow( logger ).to receive( :error )
-          allow( logger ).to receive( :pretty_backtrace ).and_return("multiline\nstring")
+          allow(logger).to receive(:error)
+          allow(logger).to receive(:pretty_backtrace).and_return("multiline\nstring")
           hypervisor.instance_variable_set(:@logger, logger)
           allow(Beaker::Command).to receive(:new).and_raise(SignalException.new('SIGTERM'))
-          expect{ hypervisor.configure }.to raise_error(SignalException)
+          expect { hypervisor.configure }.to raise_error(SignalException)
         end
       end
 
@@ -66,8 +65,8 @@ module Beaker
         it 'does not call timesync for host' do
           options[:timesync] = true
           hosts[0].options[:timesync] = false
-          allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to_not receive( :timesync )
+          allow(hypervisor).to receive(:set_env)
+          expect(hypervisor).not_to receive(:timesync)
           hypervisor.configure
         end
       end
@@ -81,27 +80,9 @@ module Beaker
           hosts[1].options[:timesync] = true
           hosts[2].options[:timesync] = true
           options[:run_in_parallel] = ['configure']
-          allow( hypervisor ).to receive( :set_env )
+          allow(hypervisor).to receive(:set_env)
           # This will only get hit if forking processes is supported and at least 2 items are being submitted to run in parallel
-          expect( InParallel::InParallelExecutor ).to receive(:_execute_in_parallel).with(any_args).and_call_original.exactly(3).times
-          hypervisor.configure
-        end
-      end
-
-      context "if :disable_iptables option set false" do
-        it "does not call disable_iptables" do
-          options[:disable_iptables] = false
-          allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_iptables ).never
-          hypervisor.configure
-        end
-      end
-
-      context "if :disable_iptables option set true" do
-        it "calls disable_iptables once" do
-          options[:disable_iptables] = true
-          allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_iptables ).exactly( 1 ).times
+          expect(InParallel::InParallelExecutor).to receive(:_execute_in_parallel).with(any_args).and_call_original.exactly(3).times
           hypervisor.configure
         end
       end
@@ -109,8 +90,8 @@ module Beaker
       context "if :disable_updates option set true" do
         it "calls disable_updates" do
           options[:disable_updates] = true
-          allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_updates ).once
+          allow(hypervisor).to receive(:set_env)
+          expect(hypervisor).to receive(:disable_updates).once
           hypervisor.configure
         end
       end
@@ -118,8 +99,8 @@ module Beaker
       context "if :disable_updates option set false" do
         it "does not call disable_updates_puppetlabs_com" do
           options[:disable_updates] = false
-          allow( hypervisor ).to receive( :set_env )
-          expect( hypervisor ).to receive( :disable_updates ).never
+          allow(hypervisor).to receive(:set_env)
+          expect(hypervisor).not_to receive(:disable_updates)
           hypervisor.configure
         end
       end
@@ -129,15 +110,11 @@ module Beaker
           options[:configure]         = false
           options[:timesync]          = true
           options[:root_keys]         = true
-          options[:add_el_extras]     = true
-          options[:disable_iptables]  = true
           options[:host_name_prefix]  = "test-"
-          expect( hypervisor ).to_not receive( :timesync )
-          expect( hypervisor ).to_not receive( :sync_root_keys )
-          expect( hypervisor ).to_not receive( :add_el_extras )
-          expect( hypervisor ).to_not receive( :disable_iptables )
-          expect( hypervisor ).to_not receive( :set_env )
-          expect( hypervisor ).to_not receive( :host_name_prefix )
+          expect(hypervisor).not_to receive(:timesync)
+          expect(hypervisor).not_to receive(:sync_root_keys)
+          expect(hypervisor).not_to receive(:set_env)
+          expect(hypervisor).not_to receive(:host_name_prefix)
           hypervisor.configure
         end
       end
@@ -145,7 +122,7 @@ module Beaker
       context 'if :configure option set true' do
         it 'does call set_env' do
           options[:configure] = true
-          expect( hypervisor ).to receive( :set_env ).once
+          expect(hypervisor).to receive(:set_env).once
           hypervisor.configure
         end
       end
@@ -154,12 +131,10 @@ module Beaker
         it "generates hostname with prefix" do
           prefix = "testing-prefix-to-test-"
           options[:host_name_prefix] = prefix
-	  expect( hypervisor.generate_host_name().start_with?(prefix) ).to be true
-	  expect( hypervisor.generate_host_name().length - prefix.length >= 15 ).to be true
+          expect(hypervisor.generate_host_name.start_with?(prefix)).to be true
+          expect(hypervisor.generate_host_name.length - prefix.length >= 15).to be true
         end
       end
-
     end
-
   end
 end

data/spec/beaker/localhost_connection_spec.rb

@@ -3,18 +3,19 @@ require 'net/ssh'
 
 module Beaker
   describe LocalConnection do
-    let( :options )   { { :logger => double('logger').as_null_object, :ssh_env_file => '/path/to/ssh/file'} }
-    subject(:connection) { LocalConnection.new(options) }
+    subject(:connection) { described_class.new(options) }
 
-    before :each do
-      allow( subject ).to receive(:sleep)
+    let(:options) { { :logger => double('logger').as_null_object, :ssh_env_file => '/path/to/ssh/file' } }
+
+    before do
+      allow(subject).to receive(:sleep)
     end
 
     describe '#self.connect' do
       it 'loggs message' do
         expect(options[:logger]).to receive(:debug).with('Local connection, no connection to start')
-        connection_constructor = LocalConnection.connect(options)
-        expect( connection_constructor ).to be_a_kind_of LocalConnection
+        connection_constructor = described_class.connect(options)
+        expect(connection_constructor).to be_a described_class
       end
     end
 
@@ -28,22 +29,22 @@ module Beaker
     describe '#with_env' do
       it 'sets envs temporarily' do
         connection.connect
-        connection.with_env({'my_env' => 'my_env_value'}) do
-          expect(ENV.to_hash).to include({'my_env' => 'my_env_value'})
+        connection.with_env({ 'my_env' => 'my_env_value' }) do
+          expect(ENV.to_hash).to include({ 'my_env' => 'my_env_value' })
         end
-        expect(ENV.to_hash).not_to include({'my_env' => 'my_env_value'})
+        expect(ENV.to_hash).not_to include({ 'my_env' => 'my_env_value' })
       end
     end
 
     describe '#execute' do
       it 'calls open3' do
-        expect( Open3 ).to receive( :capture3 ).with({}, 'my_command')
+        expect(Open3).to receive(:capture3).with({}, 'my_command')
         connection.connect
-        expect(connection.execute('my_command')).to be_a_kind_of Result
+        expect(connection.execute('my_command')).to be_a Result
       end
 
       it 'sets stdout, stderr and exitcode' do
-        allow(Open3).to receive(:capture3).and_return(['stdout', 'stderr', double({exitstatus: 0})])
+        allow(Open3).to receive(:capture3).and_return(['stdout', 'stderr', double({ exitstatus: 0 })])
         connection.connect
         result = connection.execute('my_command')
         expect(result.exit_code).to eq(0)
@@ -52,7 +53,7 @@ module Beaker
       end
 
       it 'sets logger last_result' do
-        allow(Open3).to receive(:capture3).and_return(['stdout', 'stderr', double({exitstatus: 0})])
+        allow(Open3).to receive(:capture3).and_return(['stdout', 'stderr', double({ exitstatus: 0 })])
         expect(options[:logger]).to receive(:last_result=).with(an_instance_of(Result))
         connection.connect
         connection.execute('my_command')

data/spec/beaker/logger_junit_spec.rb

@@ -1,91 +1,79 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 module Beaker
   describe LoggerJunit do
-    let( :xml_file ) { '/fake/file/location1' }
-    let( :stylesheet ) { '/fake/file/location2' }
+    let(:xml_file) { '/fake/file/location1' }
+    let(:stylesheet) { '/fake/file/location2' }
 
     describe '#is_valid_xml' do
-
       it 'rejects all invalid values' do
         invalid_values = [0x8, 0x10, 0xB, 0x0019, 0xD800, 0xDFFF, 0xFFFE, 0x99999, 0x110000]
         invalid_values.each do |value|
-          expect( LoggerJunit.is_valid_xml(value) ).to be === false
+          expect(described_class.is_valid_xml(value)).to be === false
         end
       end
 
       it 'accepts valid values' do
         valid_values = [0x9, 0xA, 0x0020, 0xD7FF, 0xE000, 0xFFFD, 0x100000, 0x10FFFF]
         valid_values.each do |value|
-          expect( LoggerJunit.is_valid_xml(value) ).to be === true
+          expect(described_class.is_valid_xml(value)).to be === true
         end
       end
-
     end
 
     describe '#escape_invalid_xml_chars' do
-
       it 'escapes invalid xml characters correctly' do
         testing_string = 'pants'
         testing_string << 0x8
-        expect( LoggerJunit.escape_invalid_xml_chars(testing_string) ).to be === 'pants\8'
+        expect(described_class.escape_invalid_xml_chars(testing_string)).to be === 'pants\8'
       end
 
       it 'leaves a string of all valid xml characters alone' do
         testing_string = 'pants man, pants!'
-        expect( LoggerJunit.escape_invalid_xml_chars(testing_string) ).to be === testing_string
+        expect(described_class.escape_invalid_xml_chars(testing_string)).to be === testing_string
       end
-
     end
 
     describe '#copy_stylesheet_into_xml_dir' do
-
       it 'copies the stylesheet into the correct location' do
-        allow( File ).to receive( :file? ) { false }
+        allow(File).to receive(:file?).and_return(false)
         correct_location = File.join(File.dirname(xml_file), File.basename(stylesheet))
-        expect( FileUtils ).to receive( :copy ).with( stylesheet, correct_location )
-        LoggerJunit.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
+        expect(FileUtils).to receive(:copy).with(stylesheet, correct_location)
+        described_class.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
       end
 
       it 'skips action if the file doesn\'t exist' do
-        allow( File ).to receive( :file? ) { true }
-        expect( FileUtils ).not_to receive( :copy )
-        LoggerJunit.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
+        allow(File).to receive(:file?).and_return(true)
+        expect(FileUtils).not_to receive(:copy)
+        described_class.copy_stylesheet_into_xml_dir(stylesheet, xml_file)
       end
-
     end
 
     describe '#finish' do
-
       it 'opens the given file for writing, and writes the doc to it' do
         mock_doc = Object.new
-        doc_xml = 'flibbity-floo'
-        allow( mock_doc ).to receive( :write ).with(File, 2)
-        expect( File ).to receive( :open ).with( xml_file, 'w' )
-        LoggerJunit.finish(mock_doc, xml_file)
+        allow(mock_doc).to receive(:write).with(File, 2)
+        expect(File).to receive(:open).with(xml_file, 'w')
+        described_class.finish(mock_doc, xml_file)
       end
-
     end
 
     describe '#write_xml' do
-
       it 'throws an error with 1-arity in the given block' do
-        allow( LoggerJunit ).to receive( :get_xml_contents )
-        expect{ LoggerJunit.write_xml(xml_file, stylesheet) do |hey| end }.to raise_error(ArgumentError)
+        allow(described_class).to receive(:get_xml_contents)
+        expect { described_class.write_xml(xml_file, stylesheet) { |hey| } }.to raise_error(ArgumentError)
       end
 
       it 'doesn\'t throw an error with 2-arity in the given block' do
-        allow( LoggerJunit ).to receive( :get_xml_contents )
-        allow( LoggerJunit ).to receive( :finish )
-        expect{ LoggerJunit.write_xml(xml_file, stylesheet) do |hey1, hey2| end }.not_to raise_error
+        allow(described_class).to receive(:get_xml_contents)
+        allow(described_class).to receive(:finish)
+        expect { described_class.write_xml(xml_file, stylesheet) { |hey1, hey2| } }.not_to raise_error
       end
 
       it 'throws an error with 3-arity in the given block' do
-        allow( LoggerJunit ).to receive( :get_xml_contents )
-        expect{ LoggerJunit.write_xml(xml_file, stylesheet) do |hey1, hey2, hey3| end }.to raise_error(ArgumentError)
+        allow(described_class).to receive(:get_xml_contents)
+        expect { described_class.write_xml(xml_file, stylesheet) { |hey1, hey2, hey3| } }.to raise_error(ArgumentError)
       end
-
     end
   end
 end