beaker 4.41.2 → 5.0.0

data/spec/beaker/shared/host_manager_spec.rb

@@ -2,199 +2,165 @@ require 'spec_helper'
 
 module Beaker
   module Shared
-
     config = RSpec::Mocks.configuration
 
     config.patch_marshal_to_support_partial_doubles = true
 
     describe HostManager do
       # The logger double as nil object doesn't work with marshal.load and marshal.unload needed for run_in_parallel.
-      let( :logger )         { double('logger') }
-      let( :host_handler )   { described_class }
-      let( :spec_block )     { Proc.new { |arr| arr } }
-      let( :platform )       { @platform || 'unix' }
-      let( :role0 )          { "role0" }
-      let( :role1 )          { :role1 }
-      let( :role2 )          { :role2 }
-      let( :hosts )          { hosts = make_hosts( { :platform => platform } )
-                               hosts[0][:roles] = ['agent', role0]
-                               hosts[1][:roles] = ['master', 'dashboard', 'agent', 'database', role1]
-                               hosts[2][:roles] = ['agent', role2]
-                               hosts }
+      let(:logger)         { double('logger') }
+      let(:host_handler)   { described_class }
+      let(:spec_block)     { Proc.new { |arr| arr } }
+      let(:platform)       { @platform || 'unix' }
+      let(:role0)          { "role0" }
+      let(:role1)          { :role1 }
+      let(:role2)          { :role2 }
+      let(:hosts)          do
+        hosts = make_hosts({ :platform => platform })
+        hosts[0][:roles] = ['agent', role0]
+        hosts[1][:roles] = ['master', 'dashboard', 'agent', 'database', role1]
+        hosts[2][:roles] = ['agent', role2]
+        hosts
+      end
 
       describe "#hosts_with_name" do
-
         it "can identify the host by name" do
-
-            expect( host_handler.hosts_with_name( hosts, 'vm1' )).to be === [hosts[0]]
-
+          expect(host_handler.hosts_with_name(hosts, 'vm1')).to be === [hosts[0]]
         end
 
         it "can identify the host by vmhostname" do
+          hosts[0][:vmhostname] = 'myname.whatever'
 
-            hosts[0][:vmhostname] = 'myname.whatever'
-
-            expect( host_handler.hosts_with_name( hosts, 'myname.whatever' )).to be === [hosts[0]]
-
+          expect(host_handler.hosts_with_name(hosts, 'myname.whatever')).to be === [hosts[0]]
         end
 
         it "can identify the host by ip" do
+          hosts[0][:ip] = '0.0.0.0'
 
-            hosts[0][:ip] = '0.0.0.0'
-
-            expect( host_handler.hosts_with_name( hosts, '0.0.0.0' )).to be === [hosts[0]]
-
+          expect(host_handler.hosts_with_name(hosts, '0.0.0.0')).to be === [hosts[0]]
         end
 
         it "returns [] when no match is found in a set of hosts" do
+          hosts[0][:ip] = '0.0.0.0'
+          hosts[0][:vmhostname] = 'myname.whatever'
 
-            hosts[0][:ip] = '0.0.0.0'
-            hosts[0][:vmhostname] = 'myname.whatever'
-
-            expect( host_handler.hosts_with_name( hosts, 'surprise' )).to be === []
-
+          expect(host_handler.hosts_with_name(hosts, 'surprise')).to be === []
         end
-
-
-
       end
 
       describe "#hosts_with_role" do
         it "can find the master in a set of hosts" do
-
-          expect( host_handler.hosts_with_role( hosts, 'master' ) ).to be === [hosts[1]]
-
+          expect(host_handler.hosts_with_role(hosts, 'master')).to be === [hosts[1]]
         end
 
         it "can find all agents in a set of hosts" do
-
-          expect( host_handler.hosts_with_role( hosts, 'agent' ) ).to be === hosts
-
+          expect(host_handler.hosts_with_role(hosts, 'agent')).to be === hosts
         end
 
         it "returns [] when no match is found in a set of hosts" do
-
-          expect( host_handler.hosts_with_role( hosts, 'surprise' ) ).to be === []
-
+          expect(host_handler.hosts_with_role(hosts, 'surprise')).to be === []
         end
-
       end
 
       describe "#only_host_with_role" do
         it "can find the single master in a set of hosts" do
-
-          expect( host_handler.only_host_with_role( hosts, 'master' ) ).to be === hosts[1]
-
+          expect(host_handler.only_host_with_role(hosts, 'master')).to be === hosts[1]
         end
 
         it "throws an error when more than one host with matching role is found" do
-
-          expect{ host_handler.only_host_with_role( hosts, 'agent' ) }.to raise_error(ArgumentError)
-
+          expect { host_handler.only_host_with_role(hosts, 'agent') }.to raise_error(ArgumentError)
         end
 
         it "throws an error when no host is found matching the role" do
-
-          expect{ host_handler.only_host_with_role( hosts, 'surprise' ) }.to raise_error(ArgumentError)
-
+          expect { host_handler.only_host_with_role(hosts, 'surprise') }.to raise_error(ArgumentError)
         end
 
         it "throws an error when role = nil" do
-          expect{ host_handler.find_at_most_one_host_with_role( hosts, nil ) }.to raise_error(ArgumentError)
+          expect { host_handler.find_at_most_one_host_with_role(hosts, nil) }.to raise_error(ArgumentError)
         end
       end
 
       describe "#find_at_most_one_host_with_role" do
         it "can find the single master in a set of hosts" do
-
-          expect( host_handler.find_at_most_one_host_with_role( hosts, 'master' ) ).to be === hosts[1]
-
+          expect(host_handler.find_at_most_one_host_with_role(hosts, 'master')).to be === hosts[1]
         end
 
         it "throws an error when more than one host with matching role is found" do
-
-          expect{ host_handler.find_at_most_one_host_with_role( hosts, 'agent' ) }.to raise_error(ArgumentError)
-
+          expect { host_handler.find_at_most_one_host_with_role(hosts, 'agent') }.to raise_error(ArgumentError)
         end
 
         it "returns nil when no host is found matching the role" do
-
-          expect( host_handler.find_at_most_one_host_with_role( hosts, 'surprise' ) ).to be_nil
-
+          expect(host_handler.find_at_most_one_host_with_role(hosts, 'surprise')).to be_nil
         end
 
         it "throws an error when role = nil" do
-          expect{ host_handler.find_at_most_one_host_with_role( hosts, nil ) }.to raise_error(ArgumentError)
+          expect { host_handler.find_at_most_one_host_with_role(hosts, nil) }.to raise_error(ArgumentError)
         end
       end
 
       describe "#run_block_on" do
         it "can execute a block against hosts identified by a string" do
-          myhosts = host_handler.run_block_on( hosts, role0 ) do |hosts|
+          myhosts = host_handler.run_block_on(hosts, role0) do |hosts|
             hosts
           end
-          expect( myhosts ).to be  === hosts[0]
+          expect(myhosts).to be === hosts[0]
         end
 
         it "can execute a block against hosts identified by a hostname" do
-          myhosts = host_handler.run_block_on( hosts, hosts[0].name ) do |hosts|
+          myhosts = host_handler.run_block_on(hosts, hosts[0].name) do |hosts|
             hosts
           end
-          expect( myhosts ).to be  === hosts[0]
+          expect(myhosts).to be === hosts[0]
         end
 
         it "can execute a block against an array of hosts" do
-          myhosts = host_handler.run_block_on( hosts ) do |hosts|
+          myhosts = host_handler.run_block_on(hosts) do |hosts|
             hosts
           end
-          expect( myhosts ).to be  === hosts
+          expect(myhosts).to be === hosts
         end
 
         it "can execute a block against an array of hosts in parallel" do
           InParallel::InParallelExecutor.logger = Logger.new(STDOUT)
           FakeFS.deactivate!
 
-          expect( InParallel::InParallelExecutor ).to receive(:_execute_in_parallel).with(any_args).and_call_original.exactly(3).times
+          expect(InParallel::InParallelExecutor).to receive(:_execute_in_parallel).with(any_args).and_call_original.exactly(3).times
 
-          myhosts = host_handler.run_block_on( hosts, nil, { :run_in_parallel => true } ) do |host|
+          myhosts = host_handler.run_block_on(hosts, nil, { :run_in_parallel => true }) do |host|
             # kind of hacky workaround to remove logger which contains a singleton method injected by rspec
-
-            host.instance_eval("remove_instance_variable(:@logger)")
+            host.send(:remove_instance_variable, :@logger)
             host
           end
 
           # After marshal load and marshal unload, the logger option (an rspec double) is no longer 'equal' to the original.
           # Array of results can be in different order.
-          new_host = myhosts.find{ |host| host.name == hosts[0].name}
-          hosts[0].options.each { |option|
+          new_host = myhosts.find { |host| host.name == hosts[0].name }
+          hosts[0].options.each do |option|
             expect(option[1]).to eq(new_host.options[option[0]]) unless option[0] == :logger
-          }
+          end
         end
 
         it "will ignore run_in_parallel global option" do
-          myhosts = host_handler.run_block_on( hosts, nil, { :run_in_parallel => [] } ) do |host|
+          myhosts = host_handler.run_block_on(hosts, nil, { :run_in_parallel => [] }) do |host|
             host
           end
-          expect( InParallel::InParallelExecutor ).not_to receive(:_execute_in_parallel).with(any_args)
+          expect(InParallel::InParallelExecutor).not_to receive(:_execute_in_parallel).with(any_args)
           expect(myhosts).to eq(hosts)
         end
 
         it "does not run in parallel if there is only 1 host in the array" do
-          myhosts = host_handler.run_block_on( [hosts[0]], nil, { :run_in_parallel => true } ) do |host|
+          myhosts = host_handler.run_block_on([hosts[0]], nil, { :run_in_parallel => true }) do |host|
             puts host
             host
           end
 
-          expect( myhosts ).to be  === [hosts[0]]
+          expect(myhosts).to be === [hosts[0]]
         end
 
         it "receives an ArgumentError on empty host" do
-          expect { host_handler.run_block_on( [], role0 ) }.to raise_error(ArgumentError)
+          expect { host_handler.run_block_on([], role0) }.to raise_error(ArgumentError)
         end
-
       end
-
     end
-
   end
 end

data/spec/beaker/shared/options_resolver_spec.rb

@@ -3,45 +3,42 @@ require 'spec_helper'
 module Beaker
   module Shared
     describe OptionsResolver do
-
       describe 'run_in_parallel?' do
-
         it 'returns true if :run_in_parallel in opts is true' do
-          expect( subject.run_in_parallel?({:run_in_parallel => true}, nil, nil) ).to be === true
+          expect(subject.run_in_parallel?({ :run_in_parallel => true }, nil, nil)).to be === true
         end
 
         it 'returns false if :run_in_parallel in opts is false' do
-          expect( subject.run_in_parallel?({:run_in_parallel => false}, nil, nil) ).to be === false
+          expect(subject.run_in_parallel?({ :run_in_parallel => false }, nil, nil)).to be === false
         end
 
         it 'returns false if :run_in_parallel in opts is an empty array' do
-          expect( subject.run_in_parallel?({:run_in_parallel => []}, nil, nil) ).to be === false
+          expect(subject.run_in_parallel?({ :run_in_parallel => [] }, nil, nil)).to be === false
         end
 
         it 'returns false if :run_in_parallel in opts is an empty array but a mode is specified in options' do
-          expect( subject.run_in_parallel?({:run_in_parallel => []}, {:run_in_parallel => ['install']}, 'install') ).to be === false
+          expect(subject.run_in_parallel?({ :run_in_parallel => [] }, { :run_in_parallel => ['install'] }, 'install')).to be === false
         end
 
         it 'returns true if opts is nil but a matching mode is specified in options' do
-          expect( subject.run_in_parallel?(nil, {:run_in_parallel => ['install']}, 'install') ).to be === true
+          expect(subject.run_in_parallel?(nil, { :run_in_parallel => ['install'] }, 'install')).to be === true
         end
 
         it 'returns false if opts is nil and a non matching mode is specified in options' do
-          expect( subject.run_in_parallel?(nil, {:run_in_parallel => ['configure']}, 'install') ).to be === false
+          expect(subject.run_in_parallel?(nil, { :run_in_parallel => ['configure'] }, 'install')).to be === false
         end
 
         it 'returns true if opts is nil and a matching mode and a non matching mode is specified in options' do
-          expect( subject.run_in_parallel?(nil, {:run_in_parallel => ['configure', 'install']}, 'install') ).to be === true
+          expect(subject.run_in_parallel?(nil, { :run_in_parallel => %w[configure install] }, 'install')).to be === true
         end
 
         it 'returns false if opts is nil and no mode is specified in options' do
-          expect( subject.run_in_parallel?(nil, {:run_in_parallel => []}, 'install') ).to be === false
+          expect(subject.run_in_parallel?(nil, { :run_in_parallel => [] }, 'install')).to be === false
         end
 
         it 'returns false if opts is false but a matching mode is specified in options' do
-          expect( subject.run_in_parallel?({:run_in_parallel => false}, {:run_in_parallel => ['install']}, 'install') ).to be === false
+          expect(subject.run_in_parallel?({ :run_in_parallel => false }, { :run_in_parallel => ['install'] }, 'install')).to be === false
         end
-
       end
     end
   end

data/spec/beaker/shared/repetition_spec.rb

@@ -3,54 +3,51 @@ require 'spec_helper'
 module Beaker
   module Shared
     describe Repetition do
-
       describe '#repeat_for' do
         it "repeats a block for 5 seconds" do
-          allow( Time ).to receive( :now ).and_return( 0, 1, 2, 3, 4, 5, 6 )
+          allow(Time).to receive(:now).and_return(0, 1, 2, 3, 4, 5, 6)
 
-          block = double( 'block' )
-          expect( block ).to receive( :exec ).exactly( 5 ).times.and_return( false )
+          block = double('block')
+          expect(block).to receive(:exec).exactly(5).times.and_return(false)
 
-          subject.repeat_for( 5 ) do
+          subject.repeat_for(5) do
             block.exec
           end
         end
 
         it "shorts circuit if the block is complete" do
-          allow( Time ).to receive( :now ).and_return( 0, 1, 2, 3, 4, 5 )
+          allow(Time).to receive(:now).and_return(0, 1, 2, 3, 4, 5)
 
-          block = double( 'block' )
-          expect( block ).to receive( :exec ).once.and_return( true )
+          block = double('block')
+          expect(block).to receive(:exec).once.and_return(true)
 
-          subject.repeat_for( 5 ) do
+          subject.repeat_for(5) do
             block.exec
           end
-
         end
-
       end
 
       describe '#repeat_fibonacci_style_for' do
         let(:block) { double("block") }
 
         it "sleeps in fibonacci increasing intervals" do
-          expect( block ).to receive( :exec ).exactly( 5 ).times.and_return( false )
-          allow( subject ).to receive( 'sleep' ).and_return( true )
+          expect(block).to receive(:exec).exactly(5).times.and_return(false)
+          allow(subject).to receive('sleep').and_return(true)
 
-          expect( subject ).to receive( :sleep ).with( 1 ).twice
-          expect( subject ).to receive( :sleep ).with( 2 ).once
-          expect( subject ).to receive( :sleep ).with( 3 ).once
-          expect( subject ).to receive( :sleep ).with( 5 ).once
-          expect( subject ).not_to receive( :sleep ).with( 8 )
+          expect(subject).to receive(:sleep).with(1).twice
+          expect(subject).to receive(:sleep).with(2).once
+          expect(subject).to receive(:sleep).with(3).once
+          expect(subject).to receive(:sleep).with(5).once
+          expect(subject).not_to receive(:sleep).with(8)
 
-          subject.repeat_fibonacci_style_for( 5 ) do
+          subject.repeat_fibonacci_style_for(5) do
             block.exec
           end
         end
 
         it "shorts circuit if the block succeeds (returns true)" do
           expect(block).to receive(:exec).and_return(false).ordered.exactly(4).times
-          expect(block).to receive(:exec).and_return( true).ordered.once
+          expect(block).to receive(:exec).and_return(true).ordered.once
 
           expect(subject).to receive(:sleep).with(1).twice
           expect(subject).to receive(:sleep).with(2).once
@@ -84,11 +81,7 @@ module Beaker
             block.fake01
           end
         end
-
-
       end
-
     end
-
   end
 end

data/spec/beaker/shared/semvar_spec.rb

@@ -3,97 +3,92 @@ require 'spec_helper'
 module Beaker
   module Shared
     describe Semvar do
-
       describe 'version_is_less' do
-
         it 'reports 2015.3.0-rc0-8-gf80879a is less than 2016' do
-          expect( subject.version_is_less( '2015.3.0-rc0-8-gf80879a', '2016' ) ).to be === true
+          expect(subject.version_is_less('2015.3.0-rc0-8-gf80879a', '2016')).to be === true
         end
 
         it 'reports 2015.3.0-rc0-8-gf80879a is less than 2015.3.0' do
-          expect( subject.version_is_less( '2015.3.0-rc0-8-gf80879a', '2015.3.0' ) ).to be === true
+          expect(subject.version_is_less('2015.3.0-rc0-8-gf80879a', '2015.3.0')).to be === true
         end
 
         it 'reports that 2015.3.0-rc0 is less than 2015.3.0-rc0-8-gf80879a' do
-          expect( subject.version_is_less( '2015.3.0-rc0', '2015.3.0-rc0-8-gf80879a' ) ).to be === true
+          expect(subject.version_is_less('2015.3.0-rc0', '2015.3.0-rc0-8-gf80879a')).to be === true
         end
 
         it 'reports that 2015.3.0-rc2 is less than 2015.3.0-rc10 (not using string comparison)' do
-          expect( subject.version_is_less( '2015.3.0-rc2', '2015.3.0-rc10' ) ).to be === true
+          expect(subject.version_is_less('2015.3.0-rc2', '2015.3.0-rc10')).to be === true
         end
 
         it 'reports that 2015.3.0 is less than 2015.3.0-1-gabc1234' do
-          expect( subject.version_is_less( '2015.3.0', '2015.3.0-1-gabc1234' ) ).to be === true
+          expect(subject.version_is_less('2015.3.0', '2015.3.0-1-gabc1234')).to be === true
         end
 
-        it 'reports that 2015.3.0-rc2 is less than 2015.3.0-1-gabc1234' do 
-          expect( subject.version_is_less( '2015.3.0-rc2', '2015.3.0-1-gabc1234' ) ).to be === true
+        it 'reports that 2015.3.0-rc2 is less than 2015.3.0-1-gabc1234' do
+          expect(subject.version_is_less('2015.3.0-rc2', '2015.3.0-1-gabc1234')).to be === true
         end
 
         it 'reports 2015.3.0-rc0-8-gf80879a is not less than 3.0.0' do
-          expect( subject.version_is_less( '2015.3.0-rc0-8-gf80879a', '3.0.0' ) ).to be === false
+          expect(subject.version_is_less('2015.3.0-rc0-8-gf80879a', '3.0.0')).to be === false
         end
 
         it 'reports 3.0.0-160-gac44cfb is not less than 3.0.0' do
-          expect( subject.version_is_less( '3.0.0-160-gac44cfb', '3.0.0' ) ).to be === false
+          expect(subject.version_is_less('3.0.0-160-gac44cfb', '3.0.0')).to be === false
         end
 
         it 'reports 3.0.0-160-gac44cfb is not less than 2.8.2' do
-          expect( subject.version_is_less( '3.0.0-160-gac44cfb', '2.8.2' ) ).to be === false
+          expect(subject.version_is_less('3.0.0-160-gac44cfb', '2.8.2')).to be === false
         end
 
         it 'reports 3.0.0 is less than 3.0.0-160-gac44cfb' do
-          expect( subject.version_is_less( '3.0.0', '3.0.0-160-gac44cfb' ) ).to be === true
+          expect(subject.version_is_less('3.0.0', '3.0.0-160-gac44cfb')).to be === true
         end
 
         it 'reports 2.8.2 is less than 3.0.0-160-gac44cfb' do
-          expect( subject.version_is_less( '2.8.2', '3.0.0-160-gac44cfb' ) ).to be === true
+          expect(subject.version_is_less('2.8.2', '3.0.0-160-gac44cfb')).to be === true
         end
 
         it 'reports 2.8 is less than 3.0.0-160-gac44cfb' do
-          expect( subject.version_is_less( '2.8', '3.0.0-160-gac44cfb' ) ).to be === true
+          expect(subject.version_is_less('2.8', '3.0.0-160-gac44cfb')).to be === true
         end
 
         it 'reports 2.8 is less than 2.9' do
-          expect( subject.version_is_less( '2.8', '2.9' ) ).to be === true
+          expect(subject.version_is_less('2.8', '2.9')).to be === true
         end
 
         it 'reports that 2015.3.0 is not less than 2015.3.0' do
-          expect( subject.version_is_less( '2015.3.0', '2015.3.0' ) ).to be == false
+          expect(subject.version_is_less('2015.3.0', '2015.3.0')).to be == false
         end
       end
 
       describe 'max_version' do
-
         it 'returns nil if versions isn\'t defined' do
-          expect( subject.max_version(nil) ).to be_nil
+          expect(subject.max_version(nil)).to be_nil
         end
 
         it 'returns nil if versions is empty' do
-          expect( subject.max_version([]) ).to be_nil
+          expect(subject.max_version([])).to be_nil
         end
 
         it 'allows you to set the default, & will return it with faulty input' do
-          expect( subject.max_version([], '5.9') ).to be === '5.9'
+          expect(subject.max_version([], '5.9')).to be === '5.9'
         end
 
         it 'returns the one value if given a length 1 array' do
-          expect( subject.max_version(['7.3']) ).to be === '7.3'
+          expect(subject.max_version(['7.3'])).to be === '7.3'
         end
 
         it 'does not mangle the versions array passed in' do
           first_array = ['1.4.3', '8.4.5', '3.5.7', '2.7.5']
           array_to_pass = first_array.dup
           subject.max_version(array_to_pass)
-          expect( array_to_pass ).to be === first_array
+          expect(array_to_pass).to be === first_array
         end
 
         it 'returns 5.8.9 from [5.8.9, 1.2.3, 0.3.5, 5.7.11]' do
-          expect( subject.max_version(['5.8.9', '1.2.3', '0.3.5', '5.7.11']) ).to be === '5.8.9'
+          expect(subject.max_version(['5.8.9', '1.2.3', '0.3.5', '5.7.11'])).to be === '5.8.9'
         end
-
       end
     end
-
   end
 end