beaker 4.38.1 → 4.39.0

data/spec/beaker/options/validator_spec.rb

@@ -4,13 +4,13 @@ module Beaker
   module Options
 
     describe Validator do
-      let(:validator) { Validator.new }
+      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') }
 
-        before :each do
+        before do
           FakeFS.deactivate!
         end
 
@@ -23,7 +23,7 @@ module Beaker
         end
 
         it 'does not throw errors on valid yaml files' do
-          expect { validator.check_yaml_file(yaml_path) }.to_not raise_error
+          expect { validator.check_yaml_file(yaml_path) }.not_to raise_error
         end
       end
 
@@ -35,7 +35,7 @@ module Beaker
 
       describe '#default_set?' do
         it 'is false when empty' do
-          expect(validator.default_set?([])).to be_falsey
+          expect(validator).not_to be_default_set([])
         end
 
         it 'throws error when more than 1' do
@@ -44,7 +44,7 @@ module Beaker
 
         ['test', 1, 3.4, true, Object.new].each do |val|
           it "is true when contents are #{val.class}" do
-            expect(validator.default_set?([val])).to be_truthy
+            expect(validator).to be_default_set([val])
           end
         end
       end
@@ -52,7 +52,7 @@ module Beaker
       describe '#valid_fail_mode?' do
         %w(stop fast slow).each do |val|
           it "does not throw error when set to #{val}" do
-            expect { validator.validate_fail_mode(val) }.to_not raise_error
+            expect { validator.validate_fail_mode(val) }.not_to raise_error
           end
 
           it "raises error when set to #{val.upcase}" do
@@ -74,7 +74,7 @@ module Beaker
       describe '#valid_preserve_hosts?' do
         %w(always onfail onpass never).each do |val|
           it "does not raise error when set to #{val}" do
-            expect { validator.validate_preserve_hosts(val) }.to_not raise_error
+            expect { validator.validate_preserve_hosts(val) }.not_to raise_error
           end
 
           it "raises error when set to #{val.upcase}" do
@@ -109,7 +109,7 @@ module Beaker
 
           expect {
             validator.validate_test_tags(tag_includes, [], tag_excludes)
-          }.to_not raise_error
+          }.not_to raise_error
         end
 
         it 'raises an error if AND and OR are both used' do
@@ -126,11 +126,11 @@ module Beaker
 
       describe '#validate_frictionless_roles' do
         it 'does nothing when roles are correct' do
-          expect { validator.validate_frictionless_roles(%w(frictionless)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless agent)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless test1)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless a role)) }.to_not raise_error
-          expect { validator.validate_frictionless_roles(%w(frictionless frictionless some_role)) }.to_not raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless agent)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless test1)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless a role)) }.not_to raise_error
+          expect { validator.validate_frictionless_roles(%w(frictionless frictionless some_role)) }.not_to raise_error
         end
 
         it 'throws errors when roles conflict' do
@@ -144,7 +144,7 @@ module Beaker
 
       describe '#validate_master_count' do
         it 'does nothing when count is exactly 1' do
-          expect { validator.validate_master_count(1) }.to_not raise_error
+          expect { validator.validate_master_count(1) }.not_to raise_error
         end
 
         it 'throws errors when greater than 1' do
@@ -156,8 +156,8 @@ module Beaker
 
       describe '#validate_files' do
         it 'does not throw an error with non-empty list' do
-          expect { validator.validate_files(['filea'], '.') }.to_not raise_error
-          expect { validator.validate_files(%w(filea fileb), '.') }.to_not raise_error
+          expect { validator.validate_files(['filea'], '.') }.not_to raise_error
+          expect { validator.validate_files(%w(filea fileb), '.') }.not_to raise_error
         end
 
         it 'raises error when file list is empty' do
@@ -168,7 +168,7 @@ module Beaker
       describe '#validate_path' do
         it 'does not throw an error when path is valid' do
           FakeFS do
-            expect { validator.validate_path('.') }.to_not raise_error
+            expect { validator.validate_path('.') }.not_to raise_error
           end
         end
 
@@ -182,7 +182,7 @@ module Beaker
         let(:blank_platform) { {'platform' => ''} }
 
         it 'does not throw an error when host has a platform' do
-          expect { validator.validate_platform(valid_platform, 'vm1') }.to_not raise_error
+          expect { validator.validate_platform(valid_platform, 'vm1') }.not_to raise_error
         end
 
         it 'throws an error when platform is not included' do

data/spec/beaker/perf_spec.rb

@@ -4,19 +4,9 @@ module Beaker
   describe Perf do
 
     context "When a Perf object is created" do
-      it 'creates a new Perf object' do
-        hosts = Array.new
-        options = Hash.new
-        options[:log_level] = :debug
-        my_logger = Beaker::Logger.new(options)
-        options[:logger] = my_logger
-        perf = Perf.new( hosts, options )
-        expect( perf ).to be_a_kind_of Perf
-      end
-
-      before(:each) do
+      before do
         @options = make_opts
-        @options[:collect_perf_data] = true
+        @options[:collect_perf_data] = 'normal'
         @options[:log_level] = :debug
         @options[:color] = false
         @my_io = StringIO.new
@@ -25,40 +15,51 @@ module Beaker
         @options[:logger] = @my_logger
       end
 
-      it 'creates a new Perf object with a single host, :collect_perf_data = true' do
+      it 'creates a new Perf object' do
+        hosts = Array.new
+        options = Hash.new
+        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
+      end
+
+
+      it 'creates a new Perf object with a single host' do
         hosts = [ make_host("myHost", @options) ]
         hosts.each { |host| host['platform'] = "centos-6-x86_64" }
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new( hosts, @options )
+        expect( perf ).to be_a_kind_of described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost/)
       end
 
-      it 'creates a new Perf object with multiple hosts, :collect_perf_data = true' do
+      it 'creates a new Perf object with multiple hosts' do
         hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options) ]
         hosts.each { |host| host['platform'] = "centos-6-x86_64" }
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new( hosts, @options )
+        expect( perf ).to be_a_kind_of 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, :collect_perf_data = true, SLES' do
+      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[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 = Perf.new( hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new( hosts, @options )
+        expect( perf ).to be_a_kind_of described_class
         expect(@my_io.string).to match(/Setup perf on host: myHost\nSetup perf on host: myOtherHost/)
       end
     end
 
-    context "When testing is finished, :collect_perf_data = true" do
-      before(:each) do
+    context "When testing is finished" do
+      before do
         @options = make_opts
-        @options[:collect_perf_data] = true
+        @options[:collect_perf_data] = 'normal'
         @options[:log_level] = :debug
         @options[:color] = false
         @hosts = [ make_host("myHost", @options), make_host("myOtherHost", @options) ]
@@ -71,8 +72,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 = Perf.new( @hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new( @hosts, @options )
+        expect( perf ).to be_a_kind_of 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
@@ -80,8 +81,8 @@ module Beaker
       it "Does the Right Thing on non-Linux hosts" do
         @hosts[0]['platform'] = "windows"
         @my_logger.remove_destination(STDOUT)
-        perf = Perf.new( @hosts, @options )
-        expect( perf ).to be_a_kind_of Perf
+        perf = described_class.new( @hosts, @options )
+        expect( perf ).to be_a_kind_of 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

data/spec/beaker/platform_spec.rb

@@ -4,7 +4,7 @@ module Beaker
   describe Platform do
 
     let( :logger )    { double( 'logger' ) }
-    let( :platform )  { Platform.new(@name) }
+    let( :platform )  { described_class.new(@name) }
 
     context 'initialize' do
 
@@ -97,6 +97,7 @@ module Beaker
         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'
@@ -160,7 +161,7 @@ module Beaker
         if YAML.respond_to?(:unsafe_load)
           YAML.unsafe_load(YAML.dump(platform))
         else
-          YAML.load(YAML.dump(platform))
+          YAML.load(YAML.dump(platform)) # rubocop:disable Security/YAMLLoad
         end
       end
 

data/spec/beaker/shared/error_handler_spec.rb

@@ -7,7 +7,7 @@ module Beaker
       let( :backtrace ) { "I'm the backtrace\nYes I am!\nI have important information" }
       let( :logger )    { double( 'logger' ) }
 
-      before :each do
+      before do
         allow( logger ).to receive( :error ).and_return( true )
         allow( logger ).to receive( :pretty_backtrace ).and_return( backtrace )
 

data/spec/beaker/shared/fog_credentials_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 module Beaker
   module Shared
     describe FogCredentials do
-      context "#get_fog_credentials" do
+      describe "#get_fog_credentials" do
         it 'raises ArgumentError when fog file is missing' do
-          expect{ get_fog_credentials( fog_file_path = '/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 ) { "" }
+          expect( File ).to receive( :open ).and_return("")
 
-          expect{ get_fog_credentials( fog_file_path = '/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
@@ -19,7 +19,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ) { data }
 
-          expect{ get_fog_credentials( fog_file_path = '/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
@@ -27,7 +27,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ) { data }
 
-          expect{ get_fog_credentials( fog_file_path = '/path/that/does/not/exist/.fog', credential = :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
@@ -35,7 +35,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ) { data }
 
-          expect{ get_fog_credentials( fog_file_path = '/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
@@ -43,7 +43,7 @@ module Beaker
 
           allow( File ).to receive( :open ).and_yield( StringIO.new( data ) )
 
-          expect{ get_fog_credentials( fog_file_path = '/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
@@ -54,7 +54,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ) { data }
 
-          expect( get_fog_credentials( fog_file_path = '/path/that/does/not/exist/.fog', credential = :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
@@ -66,7 +66,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ) { data }
 
-          expect( get_fog_credentials( fog_file_path = '/path/that/does/not/exist/.fog' )[:vmpooler_token] ).to eq( "correct_token" )
+          expect( get_fog_credentials( '/path/that/does/not/exist/.fog' )[:vmpooler_token] ).to eq( "correct_token" )
           ENV.delete( 'FOG_CREDENTIAL' )
         end
 
@@ -79,7 +79,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ) { data }
 
-          expect( get_fog_credentials( fog_file_path = '/path/that/does/not/exist/.fog', credential = :default )[:vmpooler_token] ).to eq( "correct_token" )
+          expect( get_fog_credentials( '/path/that/does/not/exist/.fog', :default )[:vmpooler_token] ).to eq( "correct_token" )
           ENV.delete( 'FOG_CREDENTIAL' )
         end
 
@@ -92,7 +92,7 @@ module Beaker
 
           expect( YAML ).to receive( :load_file ).with( '/some/other/path/to/.fog' ) { data }
 
-          expect( get_fog_credentials( fog_file_path = '/path/that/does/not/exist/.fog', credential = :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

data/spec/beaker/shared/host_manager_spec.rb

@@ -10,7 +10,7 @@ module Beaker
     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 )   { Beaker::Shared::HostManager }
+      let( :host_handler )   { described_class }
       let( :spec_block )     { Proc.new { |arr| arr } }
       let( :platform )       { @platform || 'unix' }
       let( :role0 )          { "role0" }
@@ -22,7 +22,7 @@ module Beaker
                                hosts[2][:roles] = ['agent', role2]
                                hosts }
 
-      context "#hosts_with_name" do
+      describe "#hosts_with_name" do
 
         it "can identify the host by name" do
 
@@ -59,7 +59,7 @@ module Beaker
 
       end
 
-      context "#hosts_with_role" do
+      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]]
@@ -80,7 +80,7 @@ module Beaker
 
       end
 
-      context "#only_host_with_role" do
+      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]
@@ -104,7 +104,7 @@ module Beaker
         end
       end
 
-      context "#find_at_most_one_host_with_role" do
+      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]
@@ -128,7 +128,7 @@ module Beaker
         end
       end
 
-      context "#run_block_on" do
+      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|
             hosts
@@ -165,7 +165,7 @@ module Beaker
 
           # 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.select{ |host| host.name == hosts[0].name}.first
+          new_host = myhosts.find{ |host| host.name == hosts[0].name}
           hosts[0].options.each { |option|
             expect(option[1]).to eq(new_host.options[option[0]]) unless option[0] == :logger
           }

data/spec/beaker/shared/repetition_spec.rb

@@ -16,7 +16,7 @@ module Beaker
           end
         end
 
-        it "should short circuit if the block is complete" do
+        it "shorts circuit if the block is complete" do
           allow( Time ).to receive( :now ).and_return( 0, 1, 2, 3, 4, 5 )
 
           block = double( 'block' )
@@ -37,25 +37,25 @@ module Beaker
           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 ).exactly( 2 ).times
+          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 ).to receive( :sleep ).with( 8 ).never
+          expect( subject ).not_to receive( :sleep ).with( 8 )
 
           subject.repeat_fibonacci_style_for( 5 ) do
             block.exec
           end
         end
 
-        it "should short circuit if the block succeeds (returns true)" do
+        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(subject).to receive(:sleep).with(1).exactly(2).times
+          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(anything).never
+          expect(subject).not_to receive(:sleep).with(anything)
 
           subject.repeat_fibonacci_style_for(20) do
             block.exec
@@ -65,9 +65,9 @@ module Beaker
         it "returns false if block never returns that it is done (true)" do
           expect(block).to receive(:abcd).exactly(3).times.and_return(false)
 
-          expect(subject).to receive(:sleep).with(1).exactly(2).times
+          expect(subject).to receive(:sleep).with(1).twice
           expect(subject).to receive(:sleep).with(2).once
-          expect(subject).to receive(:sleep).with(anything).never
+          expect(subject).not_to receive(:sleep).with(anything)
 
           success_result = subject.repeat_fibonacci_style_for(3) do
             block.abcd
@@ -78,7 +78,7 @@ module Beaker
         it "never sleeps if block is successful right at first (returns true)" do
           expect(block).to receive(:fake01).once.and_return(true)
 
-          expect(subject).to receive(:sleep).never
+          expect(subject).not_to receive(:sleep)
 
           subject.repeat_fibonacci_style_for(3) do
             block.fake01

data/spec/beaker/ssh_connection_spec.rb

@@ -3,6 +3,8 @@ require 'net/ssh'
 
 module Beaker
   describe SshConnection do
+    subject(:connection) { described_class.new name_hash, user, ssh_opts, options }
+
     let( :user )      { 'root'    }
     let( :ssh_opts )  { { keepalive: true, keepalive_interval: 2 } }
     let( :options )   { { :logger => double('logger').as_null_object, :ssh_connection_preference => [:ip, :vmhostname, :hostname]} }
@@ -10,16 +12,16 @@ module Beaker
     let( :vmhostname ){ "vmhostname" }
     let( :hostname)   { "my_host" }
     let( :name_hash ) { { :ip => ip, :vmhostname => vmhostname, :hostname => hostname } }
-    subject(:connection) { SshConnection.new name_hash, user, ssh_opts, options }
 
-    before :each do
+
+    before do
       allow( subject ).to receive(:sleep)
     end
 
     it 'self.connect creates connects and returns a proxy for that connection' do
       expect( Net::SSH ).to receive(:start).with( "default.ip.address", user, ssh_opts ).and_return(true)
-      connection_constructor = SshConnection.connect name_hash, user, ssh_opts, options
-      expect( connection_constructor ).to be_a_kind_of SshConnection
+      connection_constructor = described_class.connect name_hash, user, ssh_opts, options
+      expect( connection_constructor ).to be_a_kind_of described_class
     end
 
     it 'connect creates a new connection' do
@@ -35,7 +37,7 @@ module Beaker
     it 'attempts to connect by vmhostname address if ip connection fails' do
       expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts).and_return(false)
       expect( Net::SSH ).to receive( :start ).with( vmhostname, user, ssh_opts).and_return(true).once
-      expect( Net::SSH ).to receive( :start ).with( hostname, user, ssh_opts).never
+      expect( Net::SSH ).not_to receive( :start ).with( hostname, user, ssh_opts)
       connection.connect
     end
 
@@ -111,7 +113,7 @@ module Beaker
     end
 
     describe '#register_stdout_for' do
-      before :each do
+      before do
         @mock_ssh = Object.new
         expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
         connection.connect
@@ -147,7 +149,7 @@ module Beaker
     describe '#register_stderr_for' do
       let( :result ) { Beaker::Result.new('hostname', 'command') }
 
-      before :each do
+      before do
         @mock_ssh = Object.new
         expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
         connection.connect
@@ -175,9 +177,9 @@ module Beaker
         allow( @mock_channel ).to receive( :on_extended_data ).and_yield(nil, '1', @data)
 
         @mock_callback = Object.new
-        expect( @mock_callback ).to_not receive( :[] )
-        expect( result.stderr ).to_not receive( :<< )
-        expect( result.output ).to_not receive( :<< )
+        expect( @mock_callback ).not_to receive( :[] )
+        expect( result.stderr ).not_to receive( :<< )
+        expect( result.output ).not_to receive( :<< )
 
         connection.register_stderr_for @mock_channel, result, @mock_callback
       end
@@ -216,7 +218,7 @@ module Beaker
     end
 
     describe '#scp_to' do
-      before :each do
+      before do
         @mock_ssh = Object.new
         @mock_scp = Object.new
         allow( @mock_scp ).to receive( :upload! )
@@ -243,7 +245,7 @@ module Beaker
     end
 
     describe '#scp_from' do
-      before :each do
+      before do
         @mock_ssh = Object.new
         @mock_scp = Object.new
         allow( @mock_scp ).to receive( :download! )

data/spec/beaker/subcommand/subcommand_util_spec.rb

@@ -60,15 +60,19 @@ module Beaker
         it "determines if we should execute the init subcommand" do
           expect(subject.execute_subcommand?("init")).to be == true
         end
+
         it "does not attempt to execute intialize as a subcommand" do
           expect(subject.execute_subcommand?("initialize")).to be == false
         end
+
         it "determines if we should execute the help subcommand" do
           expect(subject.execute_subcommand?("help")).to be == true
         end
+
         it "determines if we should execute the provision subcommand" do
           expect(subject.execute_subcommand?("provision")).to be == true
         end
+
         it "determines that a subcommand should not be executed" do
           expect(subject.execute_subcommand?("notasubcommand")).to be == false
         end
@@ -77,15 +81,16 @@ module Beaker
 
       describe 'error_with' do
         it "the exit value should default to 1" do
-          expect(STDOUT).to receive(:puts).with("exiting").exactly(1).times
+          expect(STDOUT).to receive(:puts).with("exiting").once
           begin
             subject.error_with("exiting")
           rescue SystemExit=>e
             expect(e.status).to eq(1)
           end
         end
+
         it "the exit value should return specified value" do
-          expect(STDOUT).to receive(:puts).with("exiting").exactly(1).times
+          expect(STDOUT).to receive(:puts).with("exiting").once
           begin
             subject.error_with("exiting", {exit_code: 3})
           rescue SystemExit=>e
@@ -94,8 +99,8 @@ module Beaker
         end
 
         it "the exit value should default to 1 with a stack trace" do
-          expect(STDOUT).to receive(:puts).with("exiting").exactly(1).times
-          expect(STDOUT).to receive(:puts).with("testing").exactly(1).times
+          expect(STDOUT).to receive(:puts).with("exiting").once
+          expect(STDOUT).to receive(:puts).with("testing").once
           begin
             subject.error_with("exiting", {stack_trace: "testing"})
           rescue SystemExit=>e