beaker 4.40.1 → 5.0.0

data/spec/beaker/cli_spec.rb

@@ -12,17 +12,16 @@ end
 
 module Beaker
   describe CLI do
-
-    let(:cli)      {
+    let(:cli) do
       allow(File).to receive(:exist?).and_call_original
       allow(File).to receive(:exist?).with('.beaker.yml').and_return(false)
       described_class.new.parse_options
-    }
+    end
 
     context 'initializing and parsing' do
-      let( :cli ) {
+      let(:cli) do
         described_class.new
-      }
+      end
 
       describe 'instance variable initialization' do
         it 'creates a logger for use before parse is called' do
@@ -60,18 +59,18 @@ module Beaker
 
         it 'prints the version and exits cleanly' do
           expect(cli.logger).to receive(:notify).once
-          expect{ cli.parse_options(['--version']) }.to raise_exception(SystemExit) { |e| expect(e.success?).to eq(true) }
+          expect { cli.parse_options(['--version']) }.to raise_exception(SystemExit) { |e| expect(e.success?).to eq(true) }
         end
 
         it 'prints the help and exits cleanly' do
           expect(cli.logger).to receive(:notify).once
-          expect{ cli.parse_options(['--help']) }.to raise_exception(SystemExit) { |e| expect(e.success?).to eq(true) }
+          expect { cli.parse_options(['--help']) }.to raise_exception(SystemExit) { |e| expect(e.success?).to eq(true) }
         end
       end
 
       describe '#print_version_and_options' do
         before do
-          options  = Beaker::Options::OptionsHash.new
+          options = Beaker::Options::OptionsHash.new
           options[:beaker_version] = 'version_number'
           cli.instance_variable_set(:@options, options)
         end
@@ -83,23 +82,20 @@ module Beaker
       end
     end
 
-
     describe '#configured_options' do
       it 'returns a list of options that were not presets' do
         attribution = cli.instance_variable_get(:@attribution)
         attribution.each do |attribute, setter|
-          if setter == 'preset'
-            expect(cli.configured_options[attribute]).to be_nil
-          end
+          expect(cli.configured_options[attribute]).to be_nil if setter == 'preset'
         end
       end
     end
 
     describe '#combined_instance_and_options_hosts' do
-      let(:options_host) { {'HOSTS' => {'ubuntu' => {:options_attribute => 'options'}} }}
-      let(:instance_host ) {
-        [Beaker::Host.create('ubuntu', {:platform => 'host'}, {} )]
-      }
+      let(:options_host) { { 'HOSTS' => { 'ubuntu' => { :options_attribute => 'options' } } } }
+      let(:instance_host) do
+        [Beaker::Host.create('ubuntu', { :platform => 'host' }, {})]
+      end
 
       before do
         cli.instance_variable_set(:@options, options_host)
@@ -117,14 +113,14 @@ module Beaker
 
       context 'when hosts share IP addresses' do
         let(:options_host) do
-          {'HOSTS' => {'host1' => {:options_attribute => 'options'},
-                       'host2' => {:options_attribute => 'options'}}}
+          { 'HOSTS' => { 'host1' => { :options_attribute => 'options' },
+                         'host2' => { :options_attribute => 'options' }, } }
         end
-        let(:instance_host ) do
+        let(:instance_host) do
           [Beaker::Host.create('host1',
-                               {:platform => 'host', :ip => '127.0.0.1'}, {} ),
+                               { :platform => 'host', :ip => '127.0.0.1' }, {}),
            Beaker::Host.create('host2',
-                               {:platform => 'host', :ip => '127.0.0.1'}, {} )]
+                               { :platform => 'host', :ip => '127.0.0.1' }, {}),]
         end
 
         it 'creates separate entries for each host' do
@@ -138,7 +134,7 @@ module Beaker
 
     context 'execute!' do
       before do
-       stub_const("Beaker::Logger", double().as_null_object )
+        stub_const("Beaker::Logger", double.as_null_object)
         File.open("sample.cfg", "w+") do |file|
           file.write("HOSTS:\n")
           file.write("  myhost:\n")
@@ -147,9 +143,9 @@ module Beaker
           file.write("    platform: ubuntu-x-x\n")
           file.write("CONFIG:\n")
         end
-        allow( cli ).to receive(:setup).and_return(true)
-        allow( cli ).to receive(:validate).and_return(true)
-        allow( cli ).to receive(:provision).and_return(true)
+        allow(cli).to receive(:setup).and_return(true)
+        allow(cli).to receive(:validate).and_return(true)
+        allow(cli).to receive(:provision).and_return(true)
       end
 
       describe "test fail mode" do
@@ -157,44 +153,41 @@ module Beaker
           options = cli.instance_variable_get(:@options)
           options[:fail_mode] = 'slow'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode])
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode])
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
-          expect( cli ).to receive(:run_suite).twice
-          expect{ cli.execute! }.to raise_error
+          expect(cli).to receive(:run_suite).twice
+          expect { cli.execute! }.to raise_error
           expect(cli.instance_variable_get(:@attribution)[:logger]).to be == 'runtime'
           expect(cli.instance_variable_get(:@attribution)[:timestamp]).to be == 'runtime'
           expect(cli.instance_variable_get(:@attribution)[:beaker_version]).to be == 'runtime'
-
         end
 
         it 'continues testing after failed test if using slow fail_mode' do
           options = cli.instance_variable_get(:@options)
           options[:fail_mode] = 'slow'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
-
-          expect( cli ).to receive(:run_suite).exactly( 4 ).times
-          expect{ cli.execute! }.to raise_error
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
+          expect(cli).to receive(:run_suite).exactly(4).times
+          expect { cli.execute! }.to raise_error
         end
 
         it 'stops testing after failed test if using fast fail_mode' do
           options = cli.instance_variable_get(:@options)
           options[:fail_mode] = 'fast'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
-
-          expect( cli ).to receive(:run_suite).exactly( 3 ).times
-          expect{ cli.execute! }.to raise_error
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
+          expect(cli).to receive(:run_suite).exactly(3).times
+          expect { cli.execute! }.to raise_error
         end
       end
 
@@ -204,16 +197,15 @@ module Beaker
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'never'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).to receive(:cleanup).once
-
-          expect{ cli.execute! }.to raise_error
+          expect(netmanager).to receive(:cleanup).once
 
+          expect { cli.execute! }.to raise_error
         end
 
         it 'cleans up SUTs post testing if no tests fail and preserve_hosts = never' do
@@ -221,20 +213,18 @@ module Beaker
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'never'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).to receive(:cleanup).once
-
-          expect{ cli.execute! }.not_to raise_error
+          expect(netmanager).to receive(:cleanup).once
 
+          expect { cli.execute! }.not_to raise_error
         end
 
-
         it 'preserves SUTs post testing if no tests fail and preserve_hosts = always' do
           options = cli.instance_variable_get(:@options)
           options[:fail_mode] = 'fast'
@@ -242,18 +232,17 @@ module Beaker
           options[:log_dated_dir] = '.'
           options[:hosts_file] = 'sample.cfg'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
           cli.instance_variable_set(:@hosts, {})
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).not_to receive(:cleanup)
-
-          expect{ cli.execute! }.not_to raise_error
+          expect(netmanager).not_to receive(:cleanup)
 
+          expect { cli.execute! }.not_to raise_error
         end
 
         it 'preserves SUTs post testing if no tests fail and preserve_hosts = always' do
@@ -261,16 +250,16 @@ module Beaker
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'always'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).not_to receive(:cleanup)
+          expect(netmanager).not_to receive(:cleanup)
 
-          expect{ cli.execute! }.to raise_error
+          expect { cli.execute! }.to raise_error
         end
 
         it 'cleans up SUTs post testing if no tests fail and preserve_hosts = onfail' do
@@ -278,17 +267,16 @@ module Beaker
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'onfail'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).to receive(:cleanup).once
-
-          expect{ cli.execute! }.not_to raise_error
+          expect(netmanager).to receive(:cleanup).once
 
+          expect { cli.execute! }.not_to raise_error
         end
 
         it 'preserves SUTs post testing if tests fail and preserve_hosts = onfail' do
@@ -296,17 +284,16 @@ module Beaker
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'onfail'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).not_to receive(:cleanup)
-
-          expect{ cli.execute! }.to raise_error
+          expect(netmanager).not_to receive(:cleanup)
 
+          expect { cli.execute! }.to raise_error
         end
 
         it 'cleans up SUTs post testing if tests fail and preserve_hosts = onpass' do
@@ -314,17 +301,16 @@ module Beaker
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'onpass'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_throw("bad test")
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).to receive(:cleanup).once
-
-          expect{ cli.execute! }.to raise_error
+          expect(netmanager).to receive(:cleanup).once
 
+          expect { cli.execute! }.to raise_error
         end
 
         it 'preserves SUTs post testing if no tests fail and preserve_hosts = onpass' do
@@ -335,22 +321,22 @@ module Beaker
           options[:hosts_file] = 'sample.cfg'
           cli.instance_variable_set(:@hosts, {})
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).not_to receive(:cleanup)
+          expect(netmanager).not_to receive(:cleanup)
 
-          expect{ cli.execute! }.not_to raise_error
+          expect { cli.execute! }.not_to raise_error
         end
       end
 
       describe "#preserve_hosts_file" do
         it 'removes the pre-suite/post-suite/tests and sets to []' do
-          hosts =  make_hosts
+          hosts = make_hosts
           options = cli.instance_variable_get(:@options)
           options[:log_dated_dir] = Dir.mktmpdir
           File.open("sample.cfg", "w+") do |file|
@@ -366,10 +352,10 @@ module Beaker
             file.write("CONFIG:\n")
           end
           options[:hosts_file] = 'sample.cfg'
-          options[:pre_suite] = ['pre1', 'pre2', 'pre3']
+          options[:pre_suite] = %w[pre1 pre2 pre3]
           options[:post_suite] = ['post1']
           options[:pre_cleanup] = ['preclean1']
-          options[:tests] = ['test1', 'test2']
+          options[:tests] = %w[test1 test2]
 
           cli.instance_variable_set(:@options, options)
           cli.instance_variable_set(:@hosts, hosts)
@@ -384,17 +370,16 @@ module Beaker
       end
 
       describe 'hosts file saving when preserve_hosts should happen' do
-
         before do
           options = cli.instance_variable_get(:@options)
           options[:fail_mode] = 'fast'
           options[:preserve_hosts] = 'onpass'
           options[:hosts_file] = 'sample.cfg'
           cli.instance_variable_set(:@options, options)
-          allow( cli ).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:post_suite).and_return(true)
-          allow( cli ).to receive(:run_suite).with(:pre_cleanup).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_suite, :fast).and_return(true)
+          allow(cli).to receive(:run_suite).with(:tests, options[:fail_mode]).and_return(true)
+          allow(cli).to receive(:run_suite).with(:post_suite).and_return(true)
+          allow(cli).to receive(:run_suite).with(:pre_cleanup).and_return(true)
 
           hosts = [
             make_host('petey', { :hypervisor => 'peterPan' }),
@@ -404,13 +389,12 @@ module Beaker
 
           netmanager = double(:netmanager)
           cli.instance_variable_set(:@network_manager, netmanager)
-          expect( netmanager ).not_to receive(:cleanup)
-
+          expect(netmanager).not_to receive(:cleanup)
 
-          allow( cli ).to receive( :print_env_vars_affecting_beaker )
+          allow(cli).to receive(:print_env_vars_affecting_beaker)
           logger = cli.instance_variable_get(:@logger)
-          expect( logger ).to receive( :send ).with( anything, anything ).ordered
-          expect( logger ).to receive( :send ).with( anything, anything ).ordered
+          expect(logger).to receive(:send).with(anything, anything).ordered
+          expect(logger).to receive(:send).with(anything, anything).ordered
         end
 
         it 'executes without error' do
@@ -418,7 +402,7 @@ module Beaker
           Dir.mktmpdir do |dir|
             options[:log_dated_dir] = File.absolute_path(dir)
 
-            expect{ cli.execute! }.not_to raise_error
+            expect { cli.execute! }.not_to raise_error
           end
         end
 
@@ -430,7 +414,7 @@ module Beaker
             cli.execute!
 
             copied_hosts_file = File.join(File.absolute_path(dir), 'hosts_preserved.yml')
-            expect( File ).to exist(copied_hosts_file)
+            expect(File).to exist(copied_hosts_file)
           end
         end
 
@@ -442,7 +426,7 @@ module Beaker
             cli.execute!
 
             copied_hosts_file = File.join(File.absolute_path(dir), 'hosts_preserved.yml')
-            expect{ load_yaml_file(copied_hosts_file) }.not_to raise_error
+            expect { load_yaml_file(copied_hosts_file) }.not_to raise_error
           end
         end
 
@@ -455,7 +439,7 @@ module Beaker
 
             copied_hosts_file = File.join(File.absolute_path(dir), 'hosts_preserved.yml')
             yaml_content = load_yaml_file(copied_hosts_file)
-            expect( yaml_content['CONFIG']['provision'] ).to be_falsy
+            expect(yaml_content['CONFIG']['provision']).to be_falsy
           end
         end
 
@@ -464,17 +448,16 @@ module Beaker
           Dir.mktmpdir do |dir|
             options[:log_dated_dir] = File.absolute_path(dir)
 
-            expect( options ).not_to have_key(:hosts_preserved_yaml_file)
+            expect(options).not_to have_key(:hosts_preserved_yaml_file)
             cli.execute!
-            expect( options ).to have_key(:hosts_preserved_yaml_file)
+            expect(options).to have_key(:hosts_preserved_yaml_file)
 
             copied_hosts_file = File.join(File.absolute_path(dir), 'hosts_preserved.yml')
-            expect( options[:hosts_preserved_yaml_file] ).to be === copied_hosts_file
+            expect(options[:hosts_preserved_yaml_file]).to be === copied_hosts_file
           end
         end
 
         describe 'output text informing the user that re-use is possible' do
-
           it 'if unsupported, does not output extra text' do
             options = cli.instance_variable_get(:@options)
             Dir.mktmpdir do |dir|
@@ -482,9 +465,9 @@ module Beaker
               copied_hosts_file = File.join(File.absolute_path(dir), options[:hosts_file])
 
               logger = cli.instance_variable_get(:@logger)
-              expect( logger ).not_to receive( :send ).with( anything, "\nYou can re-run commands against the already provisioned SUT(s) by following these steps:\n")
-              expect( logger ).not_to receive( :send ).with( anything, "- change the hosts file to #{copied_hosts_file}")
-              expect( logger ).not_to receive( :send ).with( anything, '- use the --no-provision flag')
+              expect(logger).not_to receive(:send).with(anything, "\nYou can re-run commands against the already provisioned SUT(s) by following these steps:\n")
+              expect(logger).not_to receive(:send).with(anything, "- change the hosts file to #{copied_hosts_file}")
+              expect(logger).not_to receive(:send).with(anything, '- use the --no-provision flag')
 
               cli.execute!
             end
@@ -499,11 +482,11 @@ module Beaker
               hosts << make_host('fusion', { :hypervisor => 'fusion' })
 
               reproducing_cmd = "the faith of the people"
-              allow( cli ).to receive( :build_hosts_preserved_reproducing_command ).and_return( reproducing_cmd )
+              allow(cli).to receive(:build_hosts_preserved_reproducing_command).and_return(reproducing_cmd)
 
               logger = cli.instance_variable_get(:@logger)
-              expect( logger ).to receive( :send ).with( anything, "\nYou can re-run commands against the already provisioned SUT(s) with:\n").ordered
-              expect( logger ).to receive( :send ).with( anything, reproducing_cmd).ordered
+              expect(logger).to receive(:send).with(anything, "\nYou can re-run commands against the already provisioned SUT(s) with:\n").ordered
+              expect(logger).to receive(:send).with(anything, reproducing_cmd).ordered
 
               cli.execute!
             end
@@ -519,12 +502,12 @@ module Beaker
               hosts << make_host('docker', { :hypervisor => 'docker' })
 
               reproducing_cmd = "the crow flies true says the shoe to you"
-              allow( cli ).to receive( :build_hosts_preserved_reproducing_command ).and_return( reproducing_cmd )
+              allow(cli).to receive(:build_hosts_preserved_reproducing_command).and_return(reproducing_cmd)
 
               logger = cli.instance_variable_get(:@logger)
-              expect( logger ).to receive( :send ).with( anything, "\nYou can re-run commands against the already provisioned SUT(s) with:\n").ordered
-              expect( logger ).to receive( :send ).with( anything, '(docker support is untested for this feature. please reference the docs for more info)').ordered
-              expect( logger ).to receive( :send ).with( anything, reproducing_cmd).ordered
+              expect(logger).to receive(:send).with(anything, "\nYou can re-run commands against the already provisioned SUT(s) with:\n").ordered
+              expect(logger).to receive(:send).with(anything, '(docker support is untested for this feature. please reference the docs for more info)').ordered
+              expect(logger).to receive(:send).with(anything, reproducing_cmd).ordered
 
               cli.execute!
             end
@@ -540,28 +523,25 @@ module Beaker
               hosts << make_host('docker', { :hypervisor => 'docker' })
 
               logger = cli.instance_variable_get(:@logger)
-              expect( logger ).not_to receive( :send ).with( anything, "\nYou can re-run commands against the already provisioned SUT(s) with:\n")
-              expect( logger ).not_to receive( :send ).with( anything, '(docker support is untested for this feature. please reference the docs for more info)')
-              expect( logger ).not_to receive( :send ).with( anything, "- change the hosts file to #{copied_hosts_file}")
-              expect( logger ).not_to receive( :send ).with( anything, '- use the --no-provision flag')
+              expect(logger).not_to receive(:send).with(anything, "\nYou can re-run commands against the already provisioned SUT(s) with:\n")
+              expect(logger).not_to receive(:send).with(anything, '(docker support is untested for this feature. please reference the docs for more info)')
+              expect(logger).not_to receive(:send).with(anything, "- change the hosts file to #{copied_hosts_file}")
+              expect(logger).not_to receive(:send).with(anything, '- use the --no-provision flag')
 
               cli.execute!
             end
           end
-
-
         end
       end
 
       describe '#build_hosts_preserved_reproducing_command' do
-
         it 'replaces the hosts file' do
           new_hosts_file  = 'john/deer/was/here.txt'
           command_to_sub  = 'p --log-level debug --hosts pants/of/plan.poo jam --jankies --flag-business'
           command_correct = "p --log-level debug --hosts #{new_hosts_file} jam --jankies --flag-business"
 
           answer = cli.build_hosts_preserved_reproducing_command(command_to_sub, new_hosts_file)
-          expect( answer ).to be_start_with(command_correct)
+          expect(answer).to be_start_with(command_correct)
         end
 
         it 'doesn\'t replace an entry if no --hosts key is found' do
@@ -569,7 +549,7 @@ module Beaker
           command_correct = 'p --log-level debug johnnypantaloons7 --jankies --flag-business'
 
           answer = cli.build_hosts_preserved_reproducing_command(command_to_sub, 'john/deer/plans.txt')
-          expect( answer ).to be_start_with(command_correct)
+          expect(answer).to be_start_with(command_correct)
         end
 
         it 'removes any old --provision flags' do
@@ -577,7 +557,7 @@ module Beaker
           command_correct = 'jam --jankies --flag-business'
 
           answer = cli.build_hosts_preserved_reproducing_command(command_to_sub, 'can/talk/to/pigs.yml')
-          expect( answer ).to be_start_with(command_correct)
+          expect(answer).to be_start_with(command_correct)
         end
 
         it 'removes any old --no-provision flags' do
@@ -585,10 +565,9 @@ module Beaker
           command_correct = 'jam --jankoos --flag-businesses'
 
           answer = cli.build_hosts_preserved_reproducing_command(command_to_sub, 'can/talk/to/bears.yml')
-          expect( answer ).to be_start_with(command_correct)
+          expect(answer).to be_start_with(command_correct)
         end
       end
-
     end
   end
 end