beaker 4.38.1 → 4.39.0

data/spec/beaker/command_spec.rb

@@ -2,10 +2,12 @@ require 'spec_helper'
 
 module Beaker
   describe Command do
+    subject(:cmd) { described_class.new( command, args, options ) }
+
     let(:command) { @command || '/bin/ls' }
     let(:args)    { @args    || Array.new }
     let(:options) { @options || Hash.new  }
-    subject(:cmd) { Command.new( command, args, options ) }
+
     let(:host)    {
       h = Hash.new
       allow( h ).to receive( :environment_string ).and_return( '' )
@@ -74,10 +76,10 @@ module Beaker
       it 'parses things' do
         subject.options = { :v => nil, :test => nil,
                             :server => 'master', :a => 'answers.txt' }
-        expect( subject.options_string ).to match /-v/
-        expect( subject.options_string ).to match /--test/
-        expect( subject.options_string ).to match /--server=master/
-        expect( subject.options_string ).to match /-a=answers\.txt/
+        expect( subject.options_string ).to match(/-v/)
+        expect( subject.options_string ).to match(/--test/)
+        expect( subject.options_string ).to match(/--server=master/)
+        expect( subject.options_string ).to match(/-a=answers\.txt/)
       end
     end
 
@@ -90,27 +92,35 @@ module Beaker
 
 
   end
+
   describe HostCommand do
+    subject(:cmd) { described_class.new( command, args, options ) }
+
     let(:command) { @command || '/bin/ls' }
     let(:args)    { @args    || Array.new }
     let(:options) { @options || Hash.new  }
-    subject(:cmd) { HostCommand.new( command, args, options ) }
+
     let(:host)    { Hash.new }
 
     it 'returns a simple string passed in' do
       @command = "pants"
       expect( cmd.cmd_line host ).to be === @command
     end
+
     it 'returns single quoted string correctly' do
       @command = "str_p = 'pants'; str_p"
       expect( cmd.cmd_line host ).to be === @command
     end
+
     it 'returns empty strings when given the escaped version of the same' do
       @command = "\"\""
       expect( cmd.cmd_line host ).to be === ""
     end
   end
+
   describe SedCommand do
+    subject(:cmd)     { described_class.new( platform, expression, filename, options ) }
+
     let(:host)        {
       h = Hash.new
       allow( h ).to receive( :environment_string ).and_return( '' )
@@ -122,7 +132,7 @@ module Beaker
     let(:expression)  { @expression || 's/b/s/' }
     let(:filename)    { @filename   || '/fakefile' }
     let(:options)     { @options    || Hash.new  }
-    subject(:cmd)     { SedCommand.new( platform, expression, filename, options ) }
+
 
     it 'forms a basic sed command correctly' do
       expect( cmd.cmd_line host ).to be === "sed -i -e \"#{expression}\" #{filename}"

data/spec/beaker/dsl/assertions_spec.rb

@@ -26,7 +26,7 @@ CONSOLE
       expect( result ).to receive( :stderr ).and_return( '' )
 
       expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
-      expect { subject.assert_output expectation }.to_not raise_error
+      expect { subject.assert_output expectation }.not_to raise_error
     end
 
     it 'allows specifying stream markers' do
@@ -58,7 +58,7 @@ EXPECT
       expect( result ).to receive( :stderr ).and_return( stderr )
 
       expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
-      expect { subject.assert_output expectation }.to_not raise_error
+      expect { subject.assert_output expectation }.not_to raise_error
     end
 
     it 'raises an approriate error when output does not match expectations' do
@@ -69,15 +69,6 @@ Holy Crap, what HAPPENED!?!?!?
 And THIS is again on stdout
 OUTPUT
 
-        stdout = <<STDOUT
-This is on stdout
-And THIS is again on stdout
-STDOUT
-
-        stderr = <<STDERR
-Holy Crap, what HAPPENED!?!?!?
-STDERR
-
         expectation = <<EXPECT
         STDOUT> This is on stdout
         STDERR> While this is on stderr

data/spec/beaker/dsl/helpers/host_helpers_spec.rb

@@ -27,7 +27,7 @@ describe ClassMixedWithDSLHelpers do
 
   describe '#on' do
 
-    before :each do
+    before do
       result.stdout = 'stdout'
       result.stderr = 'stderr'
       result.exit_code = 0
@@ -106,7 +106,7 @@ describe ClassMixedWithDSLHelpers do
     end
 
     context 'upon command completion' do
-      before :each do
+      before do
         allow( subject ).to receive( :hosts ).and_return( hosts )
         expect( host ).to receive( :exec ).and_return( result )
         @res = subject.on( host, command )
@@ -130,7 +130,7 @@ describe ClassMixedWithDSLHelpers do
     end
 
     context 'when passed a block with arity of 1' do
-      before :each do
+      before do
         allow( subject ).to receive( :hosts ).and_return( hosts )
         expect( host ).to receive( :exec ).and_return( result )
       end
@@ -162,7 +162,7 @@ describe ClassMixedWithDSLHelpers do
     end
 
     context 'when passed a block with arity of 0' do
-      before :each do
+      before do
         allow( subject ).to receive( :hosts ).and_return( hosts )
         expect( host ).to receive( :exec ).and_return( result )
       end
@@ -170,7 +170,7 @@ describe ClassMixedWithDSLHelpers do
       it 'yields self' do
         subject.on host, command do
           expect( subject ).
-            to be_an_instance_of( ClassMixedWithDSLHelpers )
+            to be_an_instance_of( described_class )
         end
       end
 
@@ -319,7 +319,7 @@ describe ClassMixedWithDSLHelpers do
       my_opts = { :silent => true }
       tmpfile = double
 
-      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
+      expect( tmpfile ).to receive( :path ).twice.
         and_return( '/local/path/to/blah' )
 
       expect( Tempfile ).to receive( :open ).and_yield( tmpfile )
@@ -338,7 +338,7 @@ describe ClassMixedWithDSLHelpers do
       my_opts = { :silent => true, :protocol => 'rsync' }
       tmpfile = double
 
-      expect( tmpfile ).to receive( :path ).exactly( 2 ).times.
+      expect( tmpfile ).to receive( :path ).twice.
         and_return( '/local/path/to/blah' )
 
       expect( Tempfile ).to receive( :open ).and_yield( tmpfile )

data/spec/beaker/dsl/helpers/web_helpers_spec.rb

@@ -53,7 +53,7 @@ describe ClassMixedWithDSLHelpers do
       context ':cache_files_locally option is set' do
         it 'caches if the file exists locally' do
           options[:cache_files_locally] = true
-          allow(File).to receive(:exists?).and_return(true)
+          allow(File).to receive(:exist?).and_return(true)
 
           expect( logger ).to receive( :notify ).with( /^Already\ fetched\ / )
           expect( subject ).not_to receive( :open )
@@ -63,7 +63,7 @@ describe ClassMixedWithDSLHelpers do
 
         it 'doesn\'t cache if the file doesn\'t exist locally' do
           options[:cache_files_locally] = true
-          allow(File).to receive(:exists?).and_return(false)
+          allow(File).to receive(:exist?).and_return(false)
 
           expect( logger ).to receive( :notify ).with( /^Fetching/ ).ordered
           expect( logger ).to receive( :notify ).with( /^\ \ and\ saving\ to\ / ).ordered

data/spec/beaker/dsl/outcomes_spec.rb

@@ -6,6 +6,7 @@ end
 
 describe ClassMixedWithDSLOutcomes do
   let(:logger) { double }
+
   before { allow( subject ).to receive( :logger ).and_return( logger ) }
 
   describe '#pass_test' do

data/spec/beaker/dsl/roles_spec.rb

@@ -32,17 +32,20 @@ describe ClassMixedWithDSLRoles do
       expect( subject.agents ).to be == []
     end
   end
+
   describe '#master' do
     it 'returns the master if there is one' do
       @hosts = [ master, agent1 ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect( subject.master ).to be == master
     end
+
     it 'raises an error if there is more than one master' do
       @hosts = [ master, monolith ]
-      expect( subject ).to receive( :hosts ).exactly( 1 ).times.and_return( hosts )
+      expect( subject ).to receive( :hosts ).once.and_return( hosts )
       expect { subject.master }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'returns nil if no master and masterless is set' do
       @options = { :masterless => true }
       expect( subject ).to receive( :hosts ).and_return( hosts )
@@ -50,22 +53,26 @@ describe ClassMixedWithDSLRoles do
       expect( subject.master ).to be_nil
     end
   end
+
   describe '#dashboard' do
     it 'returns the dashboard if there is one' do
       @hosts = [ a_and_dash, agent1 ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect( subject.dashboard ).to be == a_and_dash
     end
+
     it 'raises an error if there is more than one dashboard' do
       @hosts = [ a_and_dash, monolith ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.dashboard }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'and raises an error if there is no dashboard' do
       @hosts = [ agent1, agent2, custom ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.dashboard }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'returns nil if no dashboard and masterless is set' do
       @options = { :masterless => true }
       expect( subject ).to receive( :hosts ).and_return( hosts )
@@ -73,22 +80,26 @@ describe ClassMixedWithDSLRoles do
       expect( subject.dashboard ).to be_nil
     end
   end
+
   describe '#database' do
     it 'returns the database if there is one' do
       @hosts = [ db, agent1 ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect( subject.database ).to be == db
     end
+
     it 'raises an error if there is more than one database' do
       @hosts = [ db, monolith ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.database }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'and raises an error if there is no database' do
       @hosts = [ agent1, agent2, custom ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.database }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'returns nil if no database and masterless is set' do
       @options = { :masterless => true }
       expect( subject ).to receive( :hosts ).and_return( hosts )
@@ -96,77 +107,95 @@ describe ClassMixedWithDSLRoles do
       expect( subject.database ).to be_nil
     end
   end
+
   describe '#not_controller' do
     it 'returns true when a host does not have the roles master/database/dashboard' do
       expect( subject.not_controller(agent1) ).to be == true
     end
+
     it 'returns false when a host has one of the roles master/database/dashboard' do
       expect( subject.not_controller(a_and_dash) ).to be == false
     end
   end
+
   describe '#agent_only' do
     it 'returns true when a host has the single role agent' do
       expect( subject.agent_only(agent1) ).to be == true
     end
+
     it 'returns false when a host has more than a single role' do
       expect( subject.agent_only(a_and_dash) ).to be == false
     end
+
     it 'returns false when a host has the role master' do
       expect( subject.agent_only(master) ).to be == false
     end
   end
+
   describe '#aio_version?' do
     it 'returns false if the host doesn\'t have a :pe_ver or :version' do
       agent1[:pe_ver] = nil
       agent1[:version] = nil
       expect( subject.aio_version?(agent1) ).to be === false
     end
+
     it 'returns false if :version < 4.0 and pe_ver is nil, type foss' do
       agent1[:pe_ver] = nil
       agent1[:version] = '3.8'
       agent1[:type] = 'foss'
       expect( subject.aio_version?(agent1) ).to be === false
     end
+
     it 'returns false if the host :pe_ver is set < 4.0' do
       agent1[:pe_ver] = '3.8'
       expect( subject.aio_version?(agent1) ).to be === false
     end
+
     it 'returns false if the host :version is set < 4.0' do
       agent1[:version] = '3.8'
       expect( subject.aio_version?(agent1) ).to be === false
     end
+
     it 'returns true if the host :pe_ver is 4.0' do
       agent1[:pe_ver] = '4.0'
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'returns true if the host :version is 4.0' do
       agent1[:version] = '4.0'
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'returns true if the host :pe_ver is 2015.5' do
       agent1[:pe_ver] = '2015.5'
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'returns true if the host has role aio' do
       agent1[:roles] = agent1[:roles] | ['aio']
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'returns true if the host is type aio' do
       agent1[:type] = 'aio'
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'returns true if the host is type aio-foss' do
       agent1[:type] = 'aio-foss'
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'returns true if the host is type foss-aio' do
       agent1[:type] = 'aio-foss'
       expect( subject.aio_version?(agent1) ).to be === true
     end
+
     it 'can take an empty string for pe_ver' do
       agent1[:pe_ver] = ''
       expect{ subject.aio_version?(agent1) }.not_to raise_error
     end
+
     it 'can take an empty string for FOSS version' do
       agent1[:version] = ''
       expect{ subject.aio_version?(agent1) }.not_to raise_error
@@ -174,14 +203,14 @@ describe ClassMixedWithDSLRoles do
 
     context 'truth table-type testing' do
 
-      before :each do
+      before do
         @old_pe_ver  = agent1[:pe_ver]
         @old_version = agent1[:version]
         @old_roles   = agent1[:roles]
         @old_type    = agent1[:type]
       end
 
-      after :each do
+      after do
         agent1[:pe_ver]   = @old_pe_ver
         agent1[:version]  = @old_version
         agent1[:roles]    = @old_roles
@@ -282,36 +311,43 @@ describe ClassMixedWithDSLRoles do
     end
 
   end
+
   describe '#aio_agent?' do
     it 'returns false if agent_only check doesn\'t pass' do
       agent1[:roles] = ['agent', 'headless']
       expect( subject.aio_agent?(agent1) ).to be === false
     end
+
     it 'returns false if aio_capable? check doesn\'t pass' do
       agent1[:pe_ver] = '3.8'
       expect( subject.aio_agent?(agent1) ).to be === false
     end
+
     it 'returns true if both checks pass' do
       agent1[:pe_ver] = '4.0'
       expect( subject.aio_agent?(agent1) ).to be === true
     end
   end
+
   describe '#default' do
     it 'returns the default host when one is specified' do
       @hosts = [ db, agent1, agent2, default, master]
-      expect( subject ).to receive( :hosts ).exactly( 1  ).times.and_return( hosts )
+      expect( subject ).to receive( :hosts ).once.and_return( hosts )
       expect( subject.default ).to be == default
     end
+
     it 'raises an error if there is more than one default' do
       @hosts = [ db, monolith, default, default ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.default }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'and raises an error if there is no default' do
       @hosts = [ agent1, agent2, custom ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
       expect { subject.default }.to raise_error Beaker::DSL::FailTest
     end
+
     it 'returns nil if no default and masterless is set' do
       @options = { :masterless => true }
       expect( subject ).to receive( :hosts ).and_return( hosts )
@@ -319,22 +355,27 @@ describe ClassMixedWithDSLRoles do
       expect( subject.default ).to be_nil
     end
   end
+
   describe '#add_role_def' do
     it 'raises an error on unsupported role format "1role"' do
       expect { subject.add_role_def( "1role" ) }.to raise_error ArgumentError
     end
+
     it 'raises an error on unsupported role format "role_!a"' do
       expect { subject.add_role_def( "role_!a" ) }.to raise_error ArgumentError
     end
+
     it 'raises an error on unsupported role format "role=="' do
       expect { subject.add_role_def( "role==" ) }.to raise_error ArgumentError
     end
+
     it 'creates new method for role "role_correct!"' do
       test_role = "role_correct!"
       subject.add_role_def( test_role )
       expect( subject ).to respond_to test_role
       subject.class.send( :undef_method, test_role )
     end
+
     it 'returns a single node for a new method for a role defined in a single node' do
       @hosts = [ agent1, agent2, monolith ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
@@ -344,6 +385,7 @@ describe ClassMixedWithDSLRoles do
       expect( subject.send( test_role )).to be == @hosts[2]
       subject.class.send( :undef_method, test_role )
     end
+
     it 'returns an array of nodes for a new method for a role defined in multiple nodes' do
       @hosts = [ agent1, agent2, monolith, custom ]
       expect( subject ).to receive( :hosts ).and_return( hosts )
@@ -354,11 +396,12 @@ describe ClassMixedWithDSLRoles do
       subject.class.send( :undef_method, test_role )
     end
   end
+
   describe '#any_hosts_as?' do
     it 'returns true if a host exists, false otherwise' do
       @hosts = [ agent1, agent2 ]
       # expect( subject ).to receive( :hosts ).and_return( hosts )
-      expect( subject ).to receive( :hosts ).exactly( 2 ).times.and_return( hosts )
+      expect( subject ).to receive( :hosts ).twice.and_return( hosts )
       expect( subject.any_hosts_as?( "agent" )).to be == true
       expect( subject.any_hosts_as?( "custom_role" )).to be == false
     end

data/spec/beaker/dsl/structure_spec.rb

@@ -9,10 +9,10 @@ end
 describe ClassMixedWithDSLStructure do
   include Beaker::DSL::Assertions
 
-  let (:logger) { double }
-  let (:metadata) { @metadata ||= {} }
+  let(:logger) { double }
+  let(:metadata) { @metadata ||= {} }
 
-  before :each do
+  before do
     allow( subject ).to receive(:metadata).and_return(metadata)
   end
 
@@ -29,9 +29,9 @@ describe ClassMixedWithDSLStructure do
     end
 
     it 'yields if a block is given' do
-      expect( subject ).to receive( :logger ).and_return( logger ).exactly(2).times
+      expect( subject ).to receive( :logger ).and_return( logger ).twice
       allow(  subject ).to receive( :set_current_step_name )
-      allow( logger ).to receive(:with_indent) { |&block| block.call }
+      allow( logger ).to receive(:with_indent).and_yield
       expect( logger ).to receive( :notify )
       expect( subject ).to receive( :foo )
       subject.step 'blah' do
@@ -51,6 +51,7 @@ describe ClassMixedWithDSLStructure do
   describe '#manual_step' do
     context 'without exec manual test option' do
       let( :options ) { {} }
+
       it 'throws an error' do
         expect( Readline ).not_to receive( :readline )
         expect { subject.manual_step 'blah' do; end }.to raise_error StandardError
@@ -59,6 +60,7 @@ describe ClassMixedWithDSLStructure do
 
     context 'with exec manual test option' do
       let( :options ) { {exec_manual_tests: nil} }
+
       it 'requires a name' do
         expect { subject.manual_step do; end }.to raise_error ArgumentError
       end
@@ -75,6 +77,7 @@ describe ClassMixedWithDSLStructure do
 
     context 'with exec manual test option set to true' do
       let( :options ) { {exec_manual_tests: true} }
+
       it 'requires a name' do
         expect { subject.manual_step do; end }.to raise_error ArgumentError
       end
@@ -102,6 +105,7 @@ describe ClassMixedWithDSLStructure do
   describe '#manual_test' do
     context 'without exec manual test option' do
       let( :options ) { {} }
+
       it 'requires a name' do
         expect { subject.manual_test do; end }.to raise_error ArgumentError
       end
@@ -117,6 +121,7 @@ describe ClassMixedWithDSLStructure do
 
     context 'with exec manual test option' do
       let( :options ) { {exec_manual_tests: true} }
+
       it 'requires a name' do
         expect { subject.manual_test do; end }.to raise_error ArgumentError
       end
@@ -130,9 +135,9 @@ describe ClassMixedWithDSLStructure do
 
       it 'yields if a block is given' do
         subject.instance_variable_set(:@options, options)
-        expect( subject ).to receive( :logger ).and_return( logger ).exactly(2).times
+        expect( subject ).to receive( :logger ).and_return( logger ).twice
         expect( logger ).to receive( :notify )
-        allow( logger ).to receive(:with_indent) { |&block| block.call }
+        allow( logger ).to receive(:with_indent).and_yield
         expect( subject ).to receive( :foo )
         subject.manual_test 'blah' do
           subject.foo
@@ -163,9 +168,9 @@ describe ClassMixedWithDSLStructure do
     end
 
     it 'yields if a block is given' do
-      expect( subject ).to receive( :logger ).and_return( logger ).exactly(2).times
+      expect( subject ).to receive( :logger ).and_return( logger ).twice
       expect( logger ).to receive( :notify )
-      allow( logger ).to receive(:with_indent) { |&block| block.call }
+      allow( logger ).to receive(:with_indent).and_yield
       expect( subject ).to receive( :foo )
       subject.test_name 'blah' do
         subject.foo
@@ -187,7 +192,7 @@ describe ClassMixedWithDSLStructure do
       subject.instance_variable_set :@teardown_procs, teardown_array
       block = lambda { 'blah' }
       expect( teardown_array ).to receive( :<< ).with( block )
-      subject.teardown &block
+      subject.teardown(&block)
     end
   end
 
@@ -198,14 +203,14 @@ describe ClassMixedWithDSLStructure do
       # We changed this lambda to use the simplest assert possible; using assert_equal
       # caused an error in minitest 5.9.0 trying to write to the file system.
       block = lambda { assert(false, 'this assertion should be caught') }
-      expect{ subject.expect_failure 'this is an expected failure', &block }.to_not raise_error
+      expect{ subject.expect_failure 'this is an expected failure', &block }.not_to raise_error
     end
 
     it 'passes when a Beaker assertion is raised' do
       expect( subject ).to receive( :logger ).and_return( logger )
       expect( logger ).to receive( :notify )
       block = lambda { assert_no_match('1', '1', '1 and 1 should not match') }
-      expect{ subject.expect_failure 'this is an expected failure', &block }.to_not raise_error
+      expect{ subject.expect_failure 'this is an expected failure', &block }.not_to raise_error
     end
 
     it 'fails when a non-Beaker, non-MiniTest assertion is raised' do
@@ -221,6 +226,7 @@ describe ClassMixedWithDSLStructure do
 
   describe 'confine' do
     let(:logger) { double.as_null_object }
+
     before do
       allow( subject ).to receive( :logger ).and_return( logger )
     end
@@ -306,7 +312,7 @@ describe ClassMixedWithDSLStructure do
       expect( subject ).to receive( :hosts= ).with( [ host1 ] )
 
       subject.confine :to, :platform => 'solaris' do |host|
-        subject.on( host, '/sbin/zonename' ).stdout =~ /:global/
+        subject.on( host, '/sbin/zonename' ).stdout.include?(':global')
       end
     end
 
@@ -344,11 +350,12 @@ describe ClassMixedWithDSLStructure do
 
   describe '#select_hosts' do
     let(:logger) { double.as_null_object }
+
     before do
       allow( subject ).to receive( :logger ).and_return( logger )
     end
 
-    it 'it returns an empty array if there are no applicable hosts' do
+    it 'returns an empty array if there are no applicable hosts' do
       hosts = [ {'thing' => 'foo'}, {'thing' => 'bar'} ]
 
       expect(subject.select_hosts( {'thing' => 'nope'}, hosts )).to be == []
@@ -375,7 +382,7 @@ describe ClassMixedWithDSLStructure do
       expect( subject ).to receive( :on ).with( host2, '/sbin/zonename' ).once.and_return( ret2 )
 
       selected_hosts = subject.select_hosts 'platform' => 'solaris' do |host|
-                             subject.on(host, '/sbin/zonename').stdout =~ /:global/
+                             subject.on(host, '/sbin/zonename').stdout.include?(':global')
       end
       expect( selected_hosts ).to be == [ host1 ]
     end