beaker 4.40.0 → 5.0.0

data/spec/beaker/ssh_connection_spec.rb

@@ -5,202 +5,198 @@ 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]} }
-    let( :ip )        { "default.ip.address" }
-    let( :vmhostname ){ "vmhostname" }
-    let( :hostname)   { "my_host" }
-    let( :name_hash ) { { :ip => ip, :vmhostname => vmhostname, :hostname => hostname } }
-
+    let(:user)      { 'root' }
+    let(:ssh_opts)  { { keepalive: true, keepalive_interval: 2 } }
+    let(:options)   { { :logger => double('logger').as_null_object, :ssh_connection_preference => %i[ip vmhostname hostname] } }
+    let(:ip)        { "default.ip.address" }
+    let(:vmhostname) { "vmhostname" }
+    let(:hostname)   { "my_host" }
+    let(:name_hash) { { :ip => ip, :vmhostname => vmhostname, :hostname => hostname } }
 
     before do
-      allow( subject ).to receive(:sleep)
+      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)
+      expect(Net::SSH).to receive(:start).with("default.ip.address", user, ssh_opts).and_return(true)
       connection_constructor = described_class.connect name_hash, user, ssh_opts, options
-      expect( connection_constructor ).to be_a_kind_of described_class
+      expect(connection_constructor).to be_a described_class
     end
 
     it 'connect creates a new connection' do
-      expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts).and_return(true)
+      expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts).and_return(true)
       connection.connect
     end
 
     it 'connect caches its connection' do
-      expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts ).once.and_return true
+      expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts).once.and_return true
       connection.connect
     end
 
     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 ).not_to receive( :start ).with( hostname, user, ssh_opts)
+      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).not_to receive(:start).with(hostname, user, ssh_opts)
       connection.connect
     end
 
     it 'attempts to connect by hostname, if vmhost + ipaddress have failed' 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(false)
-      expect( Net::SSH ).to receive( :start ).with( hostname, user, ssh_opts).and_return(true).once
+      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(false)
+      expect(Net::SSH).to receive(:start).with(hostname, user, ssh_opts).and_return(true).once
       connection.connect
-
     end
 
     describe '#close' do
-
       it 'runs ssh close' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
-        allow( mock_ssh).to receive( :closed? ).once.and_return(false)
-        expect( mock_ssh ).to receive( :close ).once
+        allow(mock_ssh).to receive(:closed?).once.and_return(false)
+        expect(mock_ssh).to receive(:close).once
         connection.close
       end
 
       it 'sets the @ssh variable to nil' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
-        allow( mock_ssh).to receive( :closed? ).once.and_return(false)
-        expect( mock_ssh ).to receive( :close ).once
+        allow(mock_ssh).to receive(:closed?).once.and_return(false)
+        expect(mock_ssh).to receive(:close).once
         connection.close
 
-        expect( connection.instance_variable_get(:@ssh) ).to be_nil
+        expect(connection.instance_variable_get(:@ssh)).to be_nil
       end
 
       it 'calls ssh shutdown & re-raises if ssh close fails with an unexpected Error' do
         mock_ssh = Object.new
-        allow( mock_ssh ).to receive( :close ) { raise StandardError }
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
+        allow(mock_ssh).to receive(:close) { raise StandardError }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
-        allow( mock_ssh).to receive( :closed? ).once.and_return(false)
-        expect( mock_ssh ).to receive( :shutdown! ).once
-        expect{ connection.close }.to raise_error(StandardError)
-        expect( connection.instance_variable_get(:@ssh) ).to be_nil
+        allow(mock_ssh).to receive(:closed?).once.and_return(false)
+        expect(mock_ssh).to receive(:shutdown!).once
+        expect { connection.close }.to raise_error(StandardError)
+        expect(connection.instance_variable_get(:@ssh)).to be_nil
       end
-
     end
 
     describe '#execute' do
       it 'raises an error if it fails' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
-        allow( subject ).to receive( :try_to_execute ) { raise Timeout::Error }
+        allow(subject).to receive(:try_to_execute) { raise Timeout::Error }
 
-        expect{ connection.execute('ls') }.to raise_error Timeout::Error
+        expect { connection.execute('ls') }.to raise_error Timeout::Error
       end
     end
 
     describe '#request_terminal_for' do
       it 'fails correctly by raising Net::SSH::Exception' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         mock_channel = Object.new
-        allow( mock_channel ).to receive( :request_pty ).and_yield(nil, false)
+        allow(mock_channel).to receive(:request_pty).and_yield(nil, false)
 
-        expect{ connection.request_terminal_for mock_channel, 'ls' }.to raise_error Net::SSH::Exception
+        expect { connection.request_terminal_for mock_channel, 'ls' }.to raise_error Net::SSH::Exception
       end
     end
 
     describe '#register_stdout_for' do
       before do
         @mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { @mock_ssh }
         connection.connect
 
         @data = '7 of clubs'
         @mock_channel = Object.new
-        allow( @mock_channel ).to receive( :on_data ).and_yield(nil, @data)
+        allow(@mock_channel).to receive(:on_data).and_yield(nil, @data)
 
         @mock_output = Object.new
         @mock_output_stdout = Object.new
         @mock_output_output = Object.new
-        allow( @mock_output ).to receive( :stdout ) { @mock_output_stdout }
-        allow( @mock_output ).to receive( :output ) { @mock_output_output }
-        allow( @mock_output_stdout ).to receive( :<< )
-        allow( @mock_output_output ).to receive( :<< )
+        allow(@mock_output).to receive(:stdout) { @mock_output_stdout }
+        allow(@mock_output).to receive(:output) { @mock_output_output }
+        allow(@mock_output_stdout).to receive(:<<)
+        allow(@mock_output_output).to receive(:<<)
       end
 
       it 'puts data into stdout & output correctly' do
-        expect( @mock_output_stdout ).to receive( :<< ).with(@data)
-        expect( @mock_output_output ).to receive( :<< ).with(@data)
+        expect(@mock_output_stdout).to receive(:<<).with(@data)
+        expect(@mock_output_output).to receive(:<<).with(@data)
 
         connection.register_stdout_for @mock_channel, @mock_output
       end
 
       it 'calls the callback if given' do
         @mock_callback = Object.new
-        expect( @mock_callback ).to receive( :[] ).with(@data)
+        expect(@mock_callback).to receive(:[]).with(@data)
 
         connection.register_stdout_for @mock_channel, @mock_output, @mock_callback
       end
     end
 
     describe '#register_stderr_for' do
-      let( :result ) { Beaker::Result.new('hostname', 'command') }
+      let(:result) { Beaker::Result.new('hostname', 'command') }
 
       before do
         @mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { @mock_ssh }
         connection.connect
 
         @data = '3 of spades'
         @mock_channel = Object.new
-        allow( @mock_channel ).to receive( :on_extended_data ).and_yield(nil, 1, @data)
+        allow(@mock_channel).to receive(:on_extended_data).and_yield(nil, 1, @data)
       end
 
       it 'puts data into stderr & output correctly' do
-        expect( result.stderr ).to receive( :<< ).with(@data)
-        expect( result.output ).to receive( :<< ).with(@data)
+        expect(result.stderr).to receive(:<<).with(@data)
+        expect(result.output).to receive(:<<).with(@data)
 
         connection.register_stderr_for @mock_channel, result
       end
 
       it 'calls the callback if given' do
         @mock_callback = Object.new
-        expect( @mock_callback ).to receive( :[] ).with(@data)
+        expect(@mock_callback).to receive(:[]).with(@data)
 
         connection.register_stderr_for @mock_channel, result, @mock_callback
       end
 
       it 'skips everything if type is not 1' do
-        allow( @mock_channel ).to receive( :on_extended_data ).and_yield(nil, '1', @data)
+        allow(@mock_channel).to receive(:on_extended_data).and_yield(nil, '1', @data)
 
         @mock_callback = Object.new
-        expect( @mock_callback ).not_to receive( :[] )
-        expect( result.stderr ).not_to receive( :<< )
-        expect( result.output ).not_to 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
     end
 
     describe '#register_exit_code_for' do
-      let( :result ) { Beaker::Result.new('hostname', 'command') }
+      let(:result) { Beaker::Result.new('hostname', 'command') }
 
       it 'assigns the output\'s exit code correctly from the data' do
         mock_ssh = Object.new
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { mock_ssh }
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { mock_ssh }
         connection.connect
 
         data = '10 of jeromes'
         mock_data = Object.new
-        allow( mock_data ).to receive( :read_long ) { data }
+        allow(mock_data).to receive(:read_long) { data }
         mock_channel = Object.new
-        allow( mock_channel ).to receive( :on_request ).with('exit-status').and_yield(nil, mock_data)
+        allow(mock_channel).to receive(:on_request).with('exit-status').and_yield(nil, mock_data)
 
         connection.register_exit_code_for mock_channel, result
-        expect( result.exit_code ).to be === data
+        expect(result.exit_code).to be === data
       end
     end
 
@@ -209,9 +205,9 @@ module Beaker
         stdin = 'jean shorts'
         mock_channel = Object.new
 
-        expect( mock_channel ).to receive( :send_data ).with(stdin).ordered.once
-        expect( mock_channel ).to receive( :process ).ordered.once
-        expect( mock_channel ).to receive( :eof! ).ordered.once
+        expect(mock_channel).to receive(:send_data).with(stdin).ordered.once
+        expect(mock_channel).to receive(:process).ordered.once
+        expect(mock_channel).to receive(:eof!).ordered.once
 
         connection.process_stdin_for mock_channel, stdin
       end
@@ -221,55 +217,52 @@ module Beaker
       before do
         @mock_ssh = Object.new
         @mock_scp = Object.new
-        allow( @mock_scp ).to receive( :upload! )
-        allow( @mock_ssh ).to receive( :scp ).and_return( @mock_scp )
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
+        allow(@mock_scp).to receive(:upload!)
+        allow(@mock_ssh).to receive(:scp).and_return(@mock_scp)
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { @mock_ssh }
         connection.connect
       end
 
       it 'calls scp.upload!' do
-        expect( @mock_scp ).to receive( :upload! ).once
+        expect(@mock_scp).to receive(:upload!).once
         connection.scp_to '', ''
       end
 
       it 'ensures the connection closes when scp.upload! errors' do
-        expect( @mock_scp ).to receive( :upload! ).once.and_raise(RuntimeError)
+        expect(@mock_scp).to receive(:upload!).once.and_raise(RuntimeError)
         expect(connection).to receive(:close).once
         connection.scp_to '', ''
       end
 
       it 'returns a result object' do
-        expect( connection.scp_to '', '' ).to be_a_kind_of Beaker::Result
+        expect(connection.scp_to '', '').to be_a Beaker::Result
       end
-
     end
 
     describe '#scp_from' do
       before do
         @mock_ssh = Object.new
         @mock_scp = Object.new
-        allow( @mock_scp ).to receive( :download! )
-        allow( @mock_ssh ).to receive( :scp ).and_return( @mock_scp )
-        expect( Net::SSH ).to receive( :start ).with( ip, user, ssh_opts) { @mock_ssh }
+        allow(@mock_scp).to receive(:download!)
+        allow(@mock_ssh).to receive(:scp).and_return(@mock_scp)
+        expect(Net::SSH).to receive(:start).with(ip, user, ssh_opts) { @mock_ssh }
         connection.connect
       end
 
       it 'calls scp.download!' do
-        expect( @mock_scp ).to receive( :download! ).once
+        expect(@mock_scp).to receive(:download!).once
         connection.scp_from '', ''
       end
 
       it 'ensures the connection closes when scp.download! errors' do
-        expect( @mock_scp ).to receive( :download! ).once.and_raise(RuntimeError)
+        expect(@mock_scp).to receive(:download!).once.and_raise(RuntimeError)
         expect(connection).to receive(:close).once
         connection.scp_from '', ''
       end
 
       it 'returns a result object' do
-        expect( connection.scp_from '', '' ).to be_a_kind_of Beaker::Result
+        expect(connection.scp_from '', '').to be_a Beaker::Result
       end
-
     end
-
   end
 end

data/spec/beaker/subcommand/subcommand_util_spec.rb

@@ -3,58 +3,57 @@ require 'spec_helper'
 module Beaker
   module Subcommands
     describe SubcommandUtil do
-
-      let(:cli) {
+      let(:cli) do
         double("cli")
-      }
+      end
 
-      let(:rake) {
+      let(:rake) do
         double("rake")
-      }
+      end
 
-      let(:file) {
+      let(:file) do
         double("file")
-      }
+      end
 
-      let(:store) {
+      let(:store) do
         double("store")
-      }
+      end
 
-      let(:host) {
+      let(:host) do
         double("host")
-      }
+      end
 
-      let(:hypervisors) {
+      let(:hypervisors) do
         double("hypervisors")
-      }
+      end
 
-      let(:hosts) {
+      let(:hosts) do
         double("hosts")
-      }
+      end
 
-      let(:hypervisors_object) {
+      let(:hypervisors_object) do
         double("hypervisors_object")
-      }
+      end
 
-      let(:hosts_object) {
+      let(:hosts_object) do
         double("hosts_object")
-      }
+      end
 
-      let(:network_manager){
+      let(:network_manager) do
         double("network_manager")
-      }
+      end
 
-      let(:save_object){
+      let(:save_object) do
         double("save_object")
-      }
+      end
 
-      let(:load_object){
+      let(:load_object) do
         double("load_object")
-      }
+      end
 
-      let(:yaml_object){
+      let(:yaml_object) do
         double("yaml_object")
-      }
+      end
 
       describe 'execute_subcommand' do
         it "determines if we should execute the init subcommand" do
@@ -78,13 +77,12 @@ module Beaker
         end
       end
 
-
       describe 'error_with' do
         it "the exit value should default to 1" do
           expect(STDOUT).to receive(:puts).with("exiting").once
           begin
             subject.error_with("exiting")
-          rescue SystemExit=>e
+          rescue SystemExit => e
             expect(e.status).to eq(1)
           end
         end
@@ -92,8 +90,8 @@ module Beaker
         it "the exit value should return specified value" do
           expect(STDOUT).to receive(:puts).with("exiting").once
           begin
-            subject.error_with("exiting", {exit_code: 3})
-          rescue SystemExit=>e
+            subject.error_with("exiting", { exit_code: 3 })
+          rescue SystemExit => e
             expect(e.status).to eq(3)
           end
         end
@@ -102,8 +100,8 @@ module Beaker
           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
+            subject.error_with("exiting", { stack_trace: "testing" })
+          rescue SystemExit => e
             expect(e.status).to eq(1)
           end
         end