beaker 4.41.2 → 5.0.0

data/spec/beaker/command_spec.rb

@@ -2,163 +2,159 @@ require 'spec_helper'
 
 module Beaker
   describe Command do
-    subject(:cmd) { described_class.new( command, args, options ) }
+    subject(:cmd) { described_class.new(command, args, options) }
 
     let(:command) { @command || '/bin/ls' }
-    let(:args)    { @args    || Array.new }
-    let(:options) { @options || Hash.new  }
+    let(:args)    { @args    || [] }
+    let(:options) { @options || {} }
 
-    let(:host)    {
-      h = Hash.new
-      allow( h ).to receive( :environment_string ).and_return( '' )
+    let(:host)    do
+      h = {}
+      allow(h).to receive(:environment_string).and_return('')
       h
-    }
+    end
 
     it 'creates a new Command object' do
       @command = '/usr/bin/blah'
-      @args    = [ 'to', 'the', 'baz' ]
+      @args    = %w[to the baz]
       @options = { :foo => 'bar' }
 
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == @args
-      expect( cmd.command ).to be == @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
+      expect(cmd.options).to be == @options
+      expect(cmd.args).to be == @args
+      expect(cmd.command).to be == @command
 
+      expect(cmd.args_string).to be == 'to the baz'
+      expect(cmd.options_string).to be == '--foo=bar'
     end
 
     describe '#:prepend_cmds' do
       it 'can prepend commands' do
         @command = '/usr/bin/blah'
-        @args    = [ 'to', 'the', 'baz' ]
+        @args    = %w[to the baz]
         @options = { :foo => 'bar' }
-        allow( host ).to receive( :prepend_commands ).and_return( 'aloha!' )
-        allow( host ).to receive( :append_commands ).and_return( '' )
+        allow(host).to receive(:prepend_commands).and_return('aloha!')
+        allow(host).to receive(:append_commands).and_return('')
 
-        expect( cmd.cmd_line( host ) ).to be ==  "aloha! /usr/bin/blah --foo=bar to the baz"
+        expect(cmd.cmd_line(host)).to be == "aloha! /usr/bin/blah --foo=bar to the baz"
       end
 
       it 'can handle no prepend_cmds' do
         @command = '/usr/bin/blah'
-        @args    = [ 'to', 'the', 'baz' ]
+        @args    = %w[to the baz]
         @options = { :foo => 'bar' }
-        allow( host ).to receive( :prepend_commands ).and_return( '' )
-        allow( host ).to receive( :append_commands ).and_return( '' )
+        allow(host).to receive(:prepend_commands).and_return('')
+        allow(host).to receive(:append_commands).and_return('')
 
-        expect( cmd.cmd_line( host ) ).to be ==  "/usr/bin/blah --foo=bar to the baz"
+        expect(cmd.cmd_line(host)).to be == "/usr/bin/blah --foo=bar to the baz"
       end
     end
 
     describe '#:append_commands' do
       it 'can append commands' do
         @command = '/usr/bin/blah'
-        @args    = [ 'to', 'the', 'baz' ]
+        @args    = %w[to the baz]
         @options = { :foo => 'bar' }
-        allow( host ).to receive( :prepend_commands ).and_return( 'aloha!' )
-        allow( host ).to receive( :append_commands ).and_return( 'moo cow' )
+        allow(host).to receive(:prepend_commands).and_return('aloha!')
+        allow(host).to receive(:append_commands).and_return('moo cow')
 
-        expect( cmd.cmd_line( host ) ).to be ==  "aloha! /usr/bin/blah --foo=bar to the baz moo cow"
+        expect(cmd.cmd_line(host)).to be == "aloha! /usr/bin/blah --foo=bar to the baz moo cow"
       end
 
       it 'can handle no append_cmds' do
         @command = '/usr/bin/blah'
-        @args    = [ 'to', 'the', 'baz' ]
+        @args    = %w[to the baz]
         @options = { :foo => 'bar' }
-        allow( host ).to receive( :prepend_commands ).and_return( '' )
-        allow( host ).to receive( :append_commands ).and_return( '' )
+        allow(host).to receive(:prepend_commands).and_return('')
+        allow(host).to receive(:append_commands).and_return('')
 
-        expect( cmd.cmd_line( host ) ).to be ==  "/usr/bin/blah --foo=bar to the baz"
+        expect(cmd.cmd_line(host)).to be == "/usr/bin/blah --foo=bar to the baz"
       end
     end
 
     describe '#options_string' do
       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/)
+                            :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/)
       end
     end
 
     describe '#args_string' do
       it 'joins an array' do
         subject.args = ['my/command and', nil, 'its args and opts']
-        expect( subject.args_string ).to be == 'my/command and its args and opts'
+        expect(subject.args_string).to be == 'my/command and its args and opts'
       end
     end
-
-
   end
 
   describe HostCommand do
-    subject(:cmd) { described_class.new( command, args, options ) }
+    subject(:cmd) { described_class.new(command, args, options) }
 
     let(:command) { @command || '/bin/ls' }
-    let(:args)    { @args    || Array.new }
-    let(:options) { @options || Hash.new  }
+    let(:args)    { @args    || [] }
+    let(:options) { @options || {} }
 
-    let(:host)    { Hash.new }
+    let(:host)    { {} }
 
     it 'returns a simple string passed in' do
       @command = "pants"
-      expect( cmd.cmd_line host ).to be === @command
+      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
+      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 === ""
+      expect(cmd.cmd_line host).to be === ""
     end
   end
 
   describe SedCommand do
-    subject(:cmd)     { described_class.new( platform, expression, filename, options ) }
+    subject(:cmd)     { described_class.new(platform, expression, filename, options) }
 
-    let(:host)        {
-      h = Hash.new
-      allow( h ).to receive( :environment_string ).and_return( '' )
-      allow( h ).to receive( :prepend_commands ).and_return( '' )
-      allow( h ).to receive( :append_commands ).and_return( '' )
+    let(:host)        do
+      h = {}
+      allow(h).to receive(:environment_string).and_return('')
+      allow(h).to receive(:prepend_commands).and_return('')
+      allow(h).to receive(:append_commands).and_return('')
       h
-    }
+    end
     let(:platform)    { @platform   || 'unix' }
     let(:expression)  { @expression || 's/b/s/' }
     let(:filename)    { @filename   || '/fakefile' }
-    let(:options)     { @options    || Hash.new  }
-
+    let(:options)     { @options    || {} }
 
     it 'forms a basic sed command correctly' do
-      expect( cmd.cmd_line host ).to be === "sed -i -e \"#{expression}\" #{filename}"
+      expect(cmd.cmd_line host).to be === "sed -i -e \"#{expression}\" #{filename}"
     end
 
     it 'provides the -i option to rewrite file in-place on non-solaris hosts' do
-      expect( cmd.cmd_line host ).to include('-i')
+      expect(cmd.cmd_line host).to include('-i')
     end
 
     describe 'on solaris hosts' do
       it 'removes the -i option correctly' do
         @platform = 'solaris'
-        expect( cmd.cmd_line host ).not_to include('-i')
+        expect(cmd.cmd_line host).not_to include('-i')
       end
 
       it 'deals with in-place file substitution correctly' do
         @platform = 'solaris'
         default_temp_file = "#{filename}.tmp"
-        expect( cmd.cmd_line host ).to include(" > #{default_temp_file} && mv #{default_temp_file} #{filename} && rm -f #{default_temp_file}")
+        expect(cmd.cmd_line host).to include(" > #{default_temp_file} && mv #{default_temp_file} #{filename} && rm -f #{default_temp_file}")
       end
 
       it 'allows you to provide the name of the temp file for in-place file substitution' do
         @platform = 'solaris'
         temp_file = 'mytemp.tmp'
         @options = { :temp_file => temp_file }
-        expect( cmd.cmd_line host ).to include(" > #{temp_file} && mv #{temp_file} #{filename} && rm -f #{temp_file}")
+        expect(cmd.cmd_line host).to include(" > #{temp_file} && mv #{temp_file} #{filename} && rm -f #{temp_file}")
       end
     end
   end

data/spec/beaker/dsl/assertions_spec.rb

@@ -7,11 +7,11 @@ end
 describe ClassMixedWithDSLAssertions do
   describe '#assert_output' do
     it 'defaults to checking stdout' do
-      stdout = <<CONSOLE
-This should not have space infront of it
-  While this should have two spaces infront of it
-    And this 3, all lines should be to stdout
-CONSOLE
+      stdout = <<~CONSOLE
+        This should not have space infront of it
+          While this should have two spaces infront of it
+            And this 3, all lines should be to stdout
+      CONSOLE
 
       expectation = <<CONSOLE
         This should not have space infront of it
@@ -20,30 +20,30 @@ CONSOLE
 CONSOLE
 
       result = double
-      expect( result ).to receive( :nil? ).at_least( :once ).and_return( false )
-      expect( result ).to receive( :stdout ).and_return( stdout )
-      expect( result ).to receive( :output ).and_return( stdout )
-      expect( result ).to receive( :stderr ).and_return( '' )
+      expect(result).to receive(:nil?).at_least(:once).and_return(false)
+      expect(result).to receive(:stdout).and_return(stdout)
+      expect(result).to receive(:output).and_return(stdout)
+      expect(result).to receive(:stderr).and_return('')
 
-      expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
+      expect(subject).to receive(:result).at_least(:once).and_return(result)
       expect { subject.assert_output expectation }.not_to raise_error
     end
 
     it 'allows specifying stream markers' do
-      output = <<OUTPUT
-This is on stdout
-While this is on stderr
-And THIS is again on stdout
-OUTPUT
+      output = <<~OUTPUT
+        This is on stdout
+        While this is on stderr
+        And THIS is again on stdout
+      OUTPUT
 
-      stdout = <<STDOUT
-This is on stdout
-And THIS is again on stdout
-STDOUT
+      stdout = <<~STDOUT
+        This is on stdout
+        And THIS is again on stdout
+      STDOUT
 
-      stderr = <<STDERR
-While this is on stderr
-STDERR
+      stderr = <<~STDERR
+        While this is on stderr
+      STDERR
 
       expectation = <<EXPECT
         STDOUT> This is on stdout
@@ -52,22 +52,22 @@ STDERR
 EXPECT
 
       result = double
-      expect( result ).to receive( :nil? ).at_least( :once ).and_return( false )
-      expect( result ).to receive( :stdout ).and_return( stdout )
-      expect( result ).to receive( :output ).and_return( output )
-      expect( result ).to receive( :stderr ).and_return( stderr )
+      expect(result).to receive(:nil?).at_least(:once).and_return(false)
+      expect(result).to receive(:stdout).and_return(stdout)
+      expect(result).to receive(:output).and_return(output)
+      expect(result).to receive(:stderr).and_return(stderr)
 
-      expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
+      expect(subject).to receive(:result).at_least(:once).and_return(result)
       expect { subject.assert_output expectation }.not_to raise_error
     end
 
     it 'raises an approriate error when output does not match expectations' do
       FakeFS.without do
-        output = <<OUTPUT
-This is on stdout
-Holy Crap, what HAPPENED!?!?!?
-And THIS is again on stdout
-OUTPUT
+        output = <<~OUTPUT
+          This is on stdout
+          Holy Crap, what HAPPENED!?!?!?
+          And THIS is again on stdout
+        OUTPUT
 
         expectation = <<EXPECT
         STDOUT> This is on stdout
@@ -75,11 +75,11 @@ OUTPUT
         STDOUT> And THIS is again on stdout
 EXPECT
         result = double
-        expect( result ).to receive( :nil? ).at_least( :once ).and_return( false )
-        expect( result ).to receive( :output ).and_return( output )
+        expect(result).to receive(:nil?).at_least(:once).and_return(false)
+        expect(result).to receive(:output).and_return(output)
 
-        expect( subject ).to receive( :result ).at_least( :once ).and_return( result )
-        expect { subject.assert_output expectation }.to raise_error( Minitest::Assertion )
+        expect(subject).to receive(:result).at_least(:once).and_return(result)
+        expect { subject.assert_output expectation }.to raise_error(MiniTest::Assertion)
       end
     end
   end