beaker 4.41.2 → 5.0.0

data/spec/beaker/host/cisco_spec.rb

@@ -2,115 +2,111 @@ require 'spec_helper'
 
 module Cisco
   describe Host do
-    let(:options)  { @options ? @options : {
-      :user => 'root',
-    } }
-    let(:platform) {
+    let(:options) do
+      @options ? @options : {
+        :user => 'root',
+      }
+    end
+    let(:platform) do
       if @platform
-        { :platform => Beaker::Platform.new( @platform) }
+        { :platform => Beaker::Platform.new(@platform) }
       else
-        { :platform => Beaker::Platform.new( 'cisco_nexus-vers-arch-extra' ) }
+        { :platform => Beaker::Platform.new('cisco_nexus-vers-arch-extra') }
       end
-    }
-    let(:host)    { make_host( 'name', options.merge(platform) ) }
+    end
+    let(:host) { make_host('name', options.merge(platform)) }
 
     describe '#prepend_commands' do
-
       context 'for cisco_nexus-7' do
-
         before do
           @platform = 'cisco_nexus-7-x86_64'
         end
 
         it 'starts with sourcing the /etc/profile script' do
           answer_correct = 'source /etc/profile;'
-          answer_test = host.prepend_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.prepend_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'uses `sudo` if not root' do
           @options = { :user => 'notroot' }
           answer_correct = "source /etc/profile; sudo -E sh -c \""
-          answer_test = host.prepend_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.prepend_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'ends with the :vrf host parameter' do
           vrf_answer = 'vrf_answer_135246'
           @options = {
-            :vrf  => vrf_answer,
+            :vrf => vrf_answer,
           }
-          answer_test = host.prepend_commands( 'fake_command' )
-          expect( answer_test ).to match( /ip netns exec #{vrf_answer}$/ )
+          answer_test = host.prepend_commands('fake_command')
+          expect(answer_test).to match(/ip netns exec #{vrf_answer}$/)
         end
 
         it 'guards against "vsh" usage (scenario we never want prefixing)' do
           answer_user_pc = 'pc_param_unchanged_13584'
-          answer_test = host.prepend_commands( 'fake/vsh/command', answer_user_pc )
-          expect( answer_test ).to be === answer_user_pc
+          answer_test = host.prepend_commands('fake/vsh/command', answer_user_pc)
+          expect(answer_test).to be === answer_user_pc
         end
 
         it 'guards against "ntpdate" usage (we dont want prefixing on nexus)' do
           answer_user_pc = 'user_pc_param_54321'
-          answer_test = host.prepend_commands( 'fake/ntpdate/command', answer_user_pc )
-          expect( answer_test ).to be === answer_user_pc
+          answer_test = host.prepend_commands('fake/ntpdate/command', answer_user_pc)
+          expect(answer_test).to be === answer_user_pc
         end
 
-
         it 'retains user-specified prepend commands when adding vrf' do
           @options = {
-            :vrf  => 'fakevrf',
+            :vrf => 'fakevrf',
             :user => 'root',
           }
           answer_prepend_commands = 'prepend'
           answer_correct = 'source /etc/profile;ip netns exec fakevrf prepend'
-          answer_test = host.prepend_commands( 'fake_command', answer_prepend_commands )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.prepend_commands('fake_command', answer_prepend_commands)
+          expect(answer_test).to be === answer_correct
         end
       end
 
       context 'for cisco_ios_xr-6' do
-
         before do
           @platform = 'cisco_ios_xr-6-x86_64'
         end
 
         it 'starts with sourcing the /etc/profile script' do
           answer_correct = 'source /etc/profile;'
-          answer_test = host.prepend_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.prepend_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'does use the :vrf host parameter if provided' do
           @options = { :vrf => 'tpnns' }
-          answer_test = host.prepend_commands( 'fake_command' )
-          expect( answer_test ).to match( /ip netns exec tpnns/ )
+          answer_test = host.prepend_commands('fake_command')
+          expect(answer_test).to match(/ip netns exec tpnns/)
         end
 
         it 'does not guard "ntpdate" usage' do
           answer_user_pc = 'user_pc_param_54321'
           answer_correct = 'source /etc/profile;user_pc_param_54321'
-          answer_test = host.prepend_commands( 'fake/ntpdate/command', answer_user_pc )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.prepend_commands('fake/ntpdate/command', answer_user_pc)
+          expect(answer_test).to be === answer_correct
         end
 
         it 'retains user-specified prepend commands when adding vrf' do
-          @options = { 
-            :vrf  => 'fakevrf', 
+          @options = {
+            :vrf => 'fakevrf',
             :user => 'root',
           }
           answer_prepend_commands = 'prepend'
           answer_correct = 'source /etc/profile;ip netns exec fakevrf prepend'
-          answer_test = host.prepend_commands( 'fake_command', answer_prepend_commands )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.prepend_commands('fake_command', answer_prepend_commands)
+          expect(answer_test).to be === answer_correct
         end
       end
     end
 
     describe '#append_commands' do
-
       context 'for cisco_nexus-7' do
-
         before do
           @platform = 'cisco_nexus-7-x86_64'
           @options = { :user => 'non_root' }
@@ -118,38 +114,37 @@ module Cisco
 
         it 'appends `"` for commands' do
           answer_correct = '"'
-          answer_test = host.append_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns nil for root user commands' do
           @options = { :user => 'root' }
           answer_correct = nil
-          answer_test = host.append_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns nil when vsh command' do
           answer_correct = nil
-          answer_test = host.append_commands( '/isan/bin/vsh -c foo' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('/isan/bin/vsh -c foo')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns `"` when command contains vsh' do
           answer_correct = '"'
-          answer_test = host.append_commands( 'fake_command -c foo vsh' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake_command -c foo vsh')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns nil when ntpdate command' do
           answer_correct = nil
-          answer_test = host.append_commands( 'fake/ntpdate/command foo' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake/ntpdate/command foo')
+          expect(answer_test).to be === answer_correct
         end
       end
 
       context 'for cisco_ios_xr-6' do
-
         before do
           @platform = 'cisco_ios_xr-6-x86_64'
           @options = { :user => 'non_root' }
@@ -157,41 +152,39 @@ module Cisco
 
         it 'appends `"` for commands' do
           answer_correct = '"'
-          answer_test = host.append_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns nil for root user commands' do
           @options = { :user => 'root' }
           answer_correct = nil
-          answer_test = host.append_commands( 'fake_command' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake_command')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns nil when vsh command' do
           answer_correct = nil
-          answer_test = host.append_commands( '/isan/bin/vsh -c foo' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('/isan/bin/vsh -c foo')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns `"` when command contains vsh' do
           answer_correct = '"'
-          answer_test = host.append_commands( 'fake_command -c foo vsh' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake_command -c foo vsh')
+          expect(answer_test).to be === answer_correct
         end
 
         it 'returns nil when ntpdate command' do
           answer_correct = nil
-          answer_test = host.append_commands( 'fake/ntpdate/command foo' )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.append_commands('fake/ntpdate/command foo')
+          expect(answer_test).to be === answer_correct
         end
       end
     end
 
     describe '#environment_string' do
-
       context 'for cisco_nexus-7' do
-
         before do
           @platform = 'cisco_nexus-7-x86_64'
         end
@@ -200,22 +193,22 @@ module Cisco
           @options = { :user => 'root' }
           env_map = { 'PATH' => '/opt/pants/2' }
           answer_correct = ' export PATH="/opt/pants/2";'
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).to be === answer_correct
         end
 
         it 'ends with a semi-colon' do
           env_map = { 'PATH' => '/opt/pants/3' }
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).to match( /\;$/ )
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).to match(/\;$/)
         end
 
         it 'turns env maps into paired strings correctly' do
           @options = { :user => 'root' }
           env_map = { 'var1' => 'ans1', 'VAR2' => 'ans2' }
           answer_correct = ' export var1="ans1" VAR1="ans1" VAR2="ans2";'
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).to be === answer_correct
         end
       end
 
@@ -228,80 +221,77 @@ module Cisco
           @options = { :user => 'notroot' }
           env_map = { 'PATH' => '/opt/pants/2' }
           answer_correct = ' env PATH="/opt/pants/2"'
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).to be === answer_correct
         end
 
         it 'uses `env` if root' do
           @options = { :user => 'root' }
           env_map = { 'PATH' => '/opt/pants/1' }
           answer_correct = ' env PATH="/opt/pants/1"'
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).to be === answer_correct
         end
 
         it 'does not end with a semi-colon' do
           env_map = { 'PATH' => '/opt/pants/3' }
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).not_to match( /\;$/ )
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).not_to match(/\;$/)
         end
 
         it 'turns env maps into paired strings correctly' do
           @options = { :user => 'root' }
           env_map = { 'VAR1' => 'ans1', 'var2' => 'ans2' }
           answer_correct = ' env VAR1="ans1" var2="ans2" VAR2="ans2"'
-          answer_test = host.environment_string( env_map )
-          expect( answer_test ).to be === answer_correct
+          answer_test = host.environment_string(env_map)
+          expect(answer_test).to be === answer_correct
         end
       end
     end
 
     describe '#package_config_dir' do
-
       it 'returns correctly for cisco platforms' do
         @platform = 'cisco_nexus-7-x86_64'
-        expect( host.package_config_dir ).to be === '/etc/yum/repos.d/'
+        expect(host.package_config_dir).to be === '/etc/yum/repos.d/'
       end
     end
 
     describe '#repo_type' do
-
       it 'returns correctly for cisco platforms' do
         @platform = 'cisco_nexus-7-x86_64'
-        expect( host.repo_type ).to be === 'rpm'
+        expect(host.repo_type).to be === 'rpm'
       end
     end
 
     describe '#validate_setup' do
-
       context 'on the cisco_nexus-7 platform' do
         before do
           @platform = 'cisco_nexus-7-x86_64'
         end
 
         it 'errors when no :vrf value is provided' do
-          expect {
+          expect do
             host.validate_setup
-          }.to raise_error( ArgumentError, /provided\ with\ a\ \:vrf\ value/ )
+          end.to raise_error(ArgumentError, /provided\ with\ a\ \:vrf\ value/)
         end
 
         it 'errors when no :user value is provided' do
           @options = {
-            :vrf  => 'fake_vrf',
+            :vrf => 'fake_vrf',
             :user => nil,
           }
-          expect {
+          expect do
             host.validate_setup
-          }.to raise_error( ArgumentError, /provided\ with\ a\ \:user\ value/ )
+          end.to raise_error(ArgumentError, /provided\ with\ a\ \:user\ value/)
         end
 
         it 'does nothing if the host is setup correctly' do
           @options = {
-            :vrf  => 'fake_vrf',
+            :vrf => 'fake_vrf',
             :user => 'notroot',
           }
           validate_test = host.validate_setup
-          expect( validate_test ).to be_nil
+          expect(validate_test).to be_nil
         end
       end
 
@@ -312,29 +302,29 @@ module Cisco
 
         it 'does nothing if no :vrf value is provided' do
           @options = {
-              :user => 'notroot',
+            :user => 'notroot',
           }
           validate_test = host.validate_setup
-          expect( validate_test ).to be_nil
+          expect(validate_test).to be_nil
         end
 
         it 'errors when no user is provided' do
           @options = {
-            :vrf  => 'fake_vrf',
+            :vrf => 'fake_vrf',
             :user => nil,
           }
-          expect {
+          expect do
             host.validate_setup
-          }.to raise_error( ArgumentError, /provided\ with\ a\ \:user\ value/ )
+          end.to raise_error(ArgumentError, /provided\ with\ a\ \:user\ value/)
         end
 
         it 'does nothing if the host is setup correctly' do
           @options = {
-            :vrf  => 'fake_vrf',
+            :vrf => 'fake_vrf',
             :user => 'notroot',
           }
           validate_test = host.validate_setup
-          expect( validate_test ).to be_nil
+          expect(validate_test).to be_nil
         end
       end
     end

data/spec/beaker/host/eos_spec.rb

@@ -3,63 +3,42 @@ require 'spec_helper'
 module Eos
   describe Host do
     let(:options)  { @options ? @options : {} }
-    let(:platform) {
+    let(:platform) do
       if @platform
-        { :platform => Beaker::Platform.new( @platform) }
+        { :platform => Beaker::Platform.new(@platform) }
       else
-        { :platform => Beaker::Platform.new( 'eos-vers-arch-extra' ) }
-      end
-    }
-    let(:host)    { make_host( 'name', options.merge(platform) ) }
-
-    describe '#puppet_agent_dev_package_info' do
-      it 'raises an error if puppet_collection isn\'t passed' do
-        expect { host.puppet_agent_dev_package_info(nil, 'maybe') }.to raise_error(ArgumentError)
-      end
-
-      it 'raises as error if puppet_agent_version isn\'t passed' do
-        expect { host.puppet_agent_dev_package_info('maybe', nil) }.to raise_error(ArgumentError)
-      end
-
-      it 'returns two strings that include the passed parameters' do
-        return1, return2 = host.puppet_agent_dev_package_info('pc1', 'pav1')
-        expect( return1 ).to match(/pc1/)
-        expect( return2 ).to match(/pav1/)
-      end
-
-      it 'gets the correct file type' do
-        _, return2 = host.puppet_agent_dev_package_info('pc1', 'pav1')
-        expect( return2 ).to match(/swix/)
+        { :platform => Beaker::Platform.new('eos-vers-arch-extra') }
       end
     end
+    let(:host) { make_host('name', options.merge(platform)) }
 
     describe '#get_remote_file' do
       it 'calls enable first' do
-        expect( host ).to receive( :execute ).with(/enable/)
-        host.get_remote_file( 'remote_url' )
+        expect(host).to receive(:execute).with(/enable/)
+        host.get_remote_file('remote_url')
       end
 
       it 'begins second line with the copy command' do
-        expect( host ).to receive( :execute ).with(/\ncopy/)
-        host.get_remote_file( 'remote_url' )
+        expect(host).to receive(:execute).with(/\ncopy/)
+        host.get_remote_file('remote_url')
       end
 
       it 'ends second line with particular extension location' do
-        expect( host ).to receive( :execute ).with(/extension\:\'$/)
-        host.get_remote_file( 'remote_url' )
+        expect(host).to receive(:execute).with(/extension\:\'$/)
+        host.get_remote_file('remote_url')
       end
     end
 
     describe '#install_from_file' do
       it 'calls enable first' do
-        expect( host ).to receive( :execute ).with(/enable/)
-        host.install_from_file( 'local_file' )
+        expect(host).to receive(:execute).with(/enable/)
+        host.install_from_file('local_file')
       end
 
       it 'begins second line with the extension command' do
-        expect( host ).to receive( :execute ).with(/\nextension/)
-        host.install_from_file( 'local_file' )
+        expect(host).to receive(:execute).with(/\nextension/)
+        host.install_from_file('local_file')
       end
     end
   end
-end
+end

data/spec/beaker/host/freebsd/exec_spec.rb

@@ -20,18 +20,15 @@ module Beaker
     end
 
     let(:opts)     { @opts || {} }
-    let(:logger)   { double( 'logger' ).as_null_object }
+    let(:logger)   { double('logger').as_null_object }
     let(:instance) { FreeBSDExecTest.new(opts, logger) }
 
     context "echo_to_file" do
-
       it "runs the correct echo command" do
-        expect( Beaker::Command ).to receive(:new).with('printf "127.0.0.1\tlocalhost localhost.localdomain\n10.255.39.23\tfreebsd-10-x64\n" > /etc/hosts').and_return('')
-        expect( instance ).to receive(:exec).with('').and_return(generate_result("hello", {:exit_code => 0}))
+        expect(Beaker::Command).to receive(:new).with('printf "127.0.0.1\tlocalhost localhost.localdomain\n10.255.39.23\tfreebsd-10-x64\n" > /etc/hosts').and_return('')
+        expect(instance).to receive(:exec).with('').and_return(generate_result("hello", { :exit_code => 0 }))
         instance.echo_to_file('127.0.0.1\tlocalhost localhost.localdomain\n10.255.39.23\tfreebsd-10-x64\n', '/etc/hosts')
       end
-
     end
   end
 end
-

data/spec/beaker/host/freebsd/pkg_spec.rb

@@ -19,13 +19,12 @@ module Beaker
       end
 
       def exec
-        #noop
+        # noop
       end
-
     end
 
     let(:opts)     { @opts || {} }
-    let(:logger)   { double( 'logger' ).as_null_object }
+    let(:logger)   { double('logger').as_null_object }
     let(:instance) { FreeBSDPkgTest.new(opts, logger) }
     let(:cond) do
       'TMPDIR=/dev/null ASSUME_ALWAYS_YES=1 PACKAGESITE=file:///nonexist pkg info -x "pkg(-devel)?\\$" > /dev/null 2>&1'
@@ -33,45 +32,45 @@ module Beaker
 
     context "pkg_info_patten" do
       it "returns correct patterns" do
-        expect( instance.pkg_info_pattern('rsync') ).to eq '^rsync-[0-9][0-9a-zA-Z_\\.,]*$'
+        expect(instance.pkg_info_pattern('rsync')).to eq '^rsync-[0-9][0-9a-zA-Z_\\.,]*$'
       end
     end
 
     context "check_pkgng_sh" do
-      it { expect( instance.check_pkgng_sh ).to eq cond }
+      it { expect(instance.check_pkgng_sh).to eq cond }
     end
 
     context "pkgng_active?" do
       it "returns true if pkgng is available" do
-        expect( instance ).to receive(:check_pkgng_sh).once.and_return("do you have pkgng?")
-        expect( Beaker::Command ).to receive(:new).with("/bin/sh -c 'do you have pkgng?'", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-        expect( instance ).to receive(:exec).with('',{:accept_all_exit_codes => true}).and_return(generate_result("hello", {:exit_code => 0}))
-        expect( instance.pkgng_active? ).to be true
+        expect(instance).to receive(:check_pkgng_sh).once.and_return("do you have pkgng?")
+        expect(Beaker::Command).to receive(:new).with("/bin/sh -c 'do you have pkgng?'", [], { :prepend_cmds => nil, :cmdexe => false }).and_return('')
+        expect(instance).to receive(:exec).with('', { :accept_all_exit_codes => true }).and_return(generate_result("hello", { :exit_code => 0 }))
+        expect(instance.pkgng_active?).to be true
       end
 
       it "returns false if pkgng is unavailable" do
-        expect( instance ).to receive(:check_pkgng_sh).once.and_return("do you have pkgng?")
-        expect( Beaker::Command ).to receive(:new).with("/bin/sh -c 'do you have pkgng?'", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-        expect( instance ).to receive(:exec).with('',{:accept_all_exit_codes => true}).and_return(generate_result("hello", {:exit_code => 127}))
-        expect( instance.pkgng_active? ).to be false
+        expect(instance).to receive(:check_pkgng_sh).once.and_return("do you have pkgng?")
+        expect(Beaker::Command).to receive(:new).with("/bin/sh -c 'do you have pkgng?'", [], { :prepend_cmds => nil, :cmdexe => false }).and_return('')
+        expect(instance).to receive(:exec).with('', { :accept_all_exit_codes => true }).and_return(generate_result("hello", { :exit_code => 127 }))
+        expect(instance.pkgng_active?).to be false
       end
     end
 
     context "install_package" do
       context "without pkgng" do
         it "runs the correct install command" do
-          expect( instance ).to receive(:pkgng_active?).once.and_return(false)
-          expect( Beaker::Command ).to receive(:new).with("pkg_add -r rsync", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-          expect( instance ).to receive(:exec).with('', {}).and_return(generate_result("hello", {:exit_code => 0}))
+          expect(instance).to receive(:pkgng_active?).once.and_return(false)
+          expect(Beaker::Command).to receive(:new).with("pkg_add -r rsync", [], { :prepend_cmds => nil, :cmdexe => false }).and_return('')
+          expect(instance).to receive(:exec).with('', {}).and_return(generate_result("hello", { :exit_code => 0 }))
           instance.install_package('rsync')
         end
       end
 
       context "with pkgng" do
         it "runs the correct install command" do
-          expect( instance ).to receive(:pkgng_active?).once.and_return(true)
-          expect( Beaker::Command ).to receive(:new).with("pkg install -y rsync", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-          expect( instance ).to receive(:exec).with('', {}).and_return(generate_result("hello", {:exit_code => 0}))
+          expect(instance).to receive(:pkgng_active?).once.and_return(true)
+          expect(Beaker::Command).to receive(:new).with("pkg install -y rsync", [], { :prepend_cmds => nil, :cmdexe => false }).and_return('')
+          expect(instance).to receive(:exec).with('', {}).and_return(generate_result("hello", { :exit_code => 0 }))
           instance.install_package('rsync')
         end
       end
@@ -80,23 +79,21 @@ module Beaker
     context "check_for_package" do
       context "without pkgng" do
         it "runs the correct checking command" do
-          expect( instance ).to receive(:pkgng_active?).once.and_return(false)
-          expect( Beaker::Command ).to receive(:new).with("pkg_info -Ix '^rsync-[0-9][0-9a-zA-Z_\\.,]*$'", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-          expect( instance ).to receive(:exec).with('', {:accept_all_exit_codes => true}).and_return(generate_result("hello", {:exit_code => 0}))
+          expect(instance).to receive(:pkgng_active?).once.and_return(false)
+          expect(Beaker::Command).to receive(:new).with("pkg_info -Ix '^rsync-[0-9][0-9a-zA-Z_\\.,]*$'", [], { :prepend_cmds => nil, :cmdexe => false }).and_return('')
+          expect(instance).to receive(:exec).with('', { :accept_all_exit_codes => true }).and_return(generate_result("hello", { :exit_code => 0 }))
           instance.check_for_package('rsync')
         end
       end
 
       context "with pkgng" do
         it "runs the correct checking command" do
-          expect( instance ).to receive(:pkgng_active?).once.and_return(true)
-          expect( Beaker::Command ).to receive(:new).with("pkg info rsync", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-          expect( instance ).to receive(:exec).with('', {:accept_all_exit_codes => true}).and_return(generate_result("hello", {:exit_code => 0}))
+          expect(instance).to receive(:pkgng_active?).once.and_return(true)
+          expect(Beaker::Command).to receive(:new).with("pkg info rsync", [], { :prepend_cmds => nil, :cmdexe => false }).and_return('')
+          expect(instance).to receive(:exec).with('', { :accept_all_exit_codes => true }).and_return(generate_result("hello", { :exit_code => 0 }))
           instance.check_for_package('rsync')
         end
       end
     end
-
   end
 end
-

data/spec/beaker/host/mac/exec_spec.rb

@@ -17,11 +17,10 @@ module Beaker
       def to_s
         "me"
       end
-
     end
 
     let(:opts)     { @opts || {} }
-    let(:logger)   { double( 'logger' ).as_null_object }
+    let(:logger)   { double('logger').as_null_object }
     let(:instance) { MacExecTest.new(opts, logger) }
 
     describe '#selinux_enabled?' do
@@ -36,7 +35,7 @@ module Beaker
       it 'calls execute with touch and timestamp' do
         time = '190101010000'
         path = '/path/to/file'
-        expect( instance ).to receive(:execute).with("touch -mt #{time} #{path}").and_return(0)
+        expect(instance).to receive(:execute).with("touch -mt #{time} #{path}").and_return(0)
 
         instance.modified_at(path, time)
       end