beaker 4.40.1 → 5.0.0

data/spec/beaker/host/unix_spec.rb

@@ -2,243 +2,47 @@ require 'spec_helper'
 
 module Unix
   describe Host do
-    let( :options )  { @options ? @options : {} }
-    let( :platform ) {
+    let(:options)  { @options ? @options : {} }
+    let(:platform) do
       if @platform
-        { :platform => Beaker::Platform.new( @platform) }
+        { :platform => Beaker::Platform.new(@platform) }
       else
-        { :platform => Beaker::Platform.new( 'el-vers-arch-extra' ) }
-      end
-    }
-    let( :host )    { make_host( 'name', options.merge(platform) ) }
-    let( :opts )    { { :download_url => 'download_url' } }
-
-
-    describe '#solaris_puppet_agent_dev_package_info' do
-      it 'raises an error if puppet_collection is not passed' do
-        expect {
-          host.solaris_puppet_agent_dev_package_info
-        }.to raise_error( ArgumentError, /^Must\ provide\ puppet_collection/ )
-      end
-
-      it 'raises an error if puppet_agent_version is not passed' do
-        expect {
-          host.solaris_puppet_agent_dev_package_info( 'collection' )
-        }.to raise_error( ArgumentError, /^Must\ provide\ puppet_agent_version/ )
-      end
-
-      it 'raises an error if the download URL is not passed' do
-        expect {
-          host.solaris_puppet_agent_dev_package_info( 'collection', 'version' )
-        }.to raise_error( ArgumentError, /^Must\ provide\ opts\[\:download_url\]/ )
-      end
-
-      it 'raises an error if called on a non-solaris platform' do
-        @platform = 'ubuntu-14.04-x86_64'
-        opts = { :download_url => 'download_url' }
-        expect {
-          host.solaris_puppet_agent_dev_package_info( 'collection', 'version', opts )
-        }.to raise_error( ArgumentError, /^Incorrect\ platform \'ubuntu\'/ )
-      end
-
-      it 'sets release_path_end correctly' do
-        @platform = 'solaris-10-arch'
-        allow( host ).to receive( :link_exists? ).and_return(true)
-        release_path_end, _ = host.solaris_puppet_agent_dev_package_info(
-          'pa_collection4', 'pa_version', opts )
-        expect( release_path_end ).to be === "solaris/10/pa_collection4"
-      end
-
-      it 'sets the arch correctly for x86_64 platforms' do
-        @platform = 'solaris-10-x86_64'
-        allow( host ).to receive( :link_exists? ).and_return(true)
-        _, release_file = host.solaris_puppet_agent_dev_package_info(
-          'pa_collection', 'pa_version', opts )
-        expect( release_file ).to     match( /i386/   )
-        expect( release_file ).not_to match( /x86_64/ )
-      end
-
-      context 'sets release_file name appropriately for puppet-agent version' do
-        context 'on solaris 10' do
-          before do
-            @platform = 'solaris-10-arch'
-          end
-
-          [ '1.0.1.786.477',
-            '1.0.1.786.a477',
-            '1.0.1.786.477-',
-            '1.0.1.0000786.477',
-            '1.000000.1.786.477',
-            '-1.0.1.786.477',
-            '1.2.5.38.6813',
-          ].each do |pa_version|
-
-            context "#{pa_version}" do
-              it "URL exists" do
-                allow( host ).to receive( :link_exists? ).and_return(true)
-                _, release_file = host.solaris_puppet_agent_dev_package_info(
-                  'pa_collection', pa_version, opts )
-                expect( release_file ).to be === "puppet-agent-#{pa_version}-1.arch.pkg.gz"
-              end
-
-              it "fallback URL" do
-                allow( host ).to receive( :link_exists? ).and_return(false)
-                _, release_file = host.solaris_puppet_agent_dev_package_info(
-                  'pa_collection', pa_version, opts )
-                expect( release_file ).to be === "puppet-agent-#{pa_version}.arch.pkg.gz"
-              end
-            end
-          end
-        end
-
-        context 'on solaris 11' do
-          before do
-            @platform = 'solaris-11-arch'
-          end
-
-          [
-            ['1.0.1.786.477', '1.0.1.786.477'],
-            ['1.0.1.786.a477', '1.0.1.786.477'],
-            ['1.0.1.786.477-', '1.0.1.786.477'],
-            ['1.0.1.0000786.477', '1.0.1.786.477'],
-            ['1.000000.1.786.477', '1.0.1.786.477'],
-            ['-1.0.1.786.477', '1.0.1.786.477'],
-            ['1.2.5-78-gbb3022f', '1.2.5.78.3022'],
-            ['1.2.5.38.6813', '1.2.5.38.6813']
-          ].each do |pa_version, pa_version_cleaned|
-
-            context "#{pa_version}" do
-              it "URL exists" do
-                allow( host ).to receive( :link_exists? ).and_return(true)
-                _, release_file = host.solaris_puppet_agent_dev_package_info(
-                  'pa_collection', pa_version, opts )
-                expect( release_file ).to be === "puppet-agent@#{pa_version_cleaned},5.11-1.arch.p5p"
-              end
-
-              it "fallback URL" do
-                allow( host ).to receive( :link_exists? ).and_return(false)
-                _, release_file = host.solaris_puppet_agent_dev_package_info(
-                  'pa_collection', pa_version, opts )
-                expect( release_file ).to be === "puppet-agent@#{pa_version_cleaned},5.11.arch.p5p"
-              end
-            end
-          end
-        end
-      end
-    end
-
-    describe '#puppet_agent_dev_package_info' do
-
-      it 'raises an error if puppet_collection is not passed' do
-        expect {
-          host.puppet_agent_dev_package_info
-        }.to raise_error( ArgumentError, /^Must\ provide\ puppet_collection/ )
-      end
-
-      it 'raises an error if puppet_agent_version is not passed' do
-        expect {
-          host.puppet_agent_dev_package_info( 'collection' )
-        }.to raise_error( ArgumentError, /^Must\ provide\ puppet_agent_version/ )
-      end
-
-      it 'raises an error on unknown platforms' do
-        @platform = 'ubuntu-14.04-x86_64'
-        expect {
-          host.puppet_agent_dev_package_info( 'collection', 'version' )
-        }.to raise_error( ArgumentError, /^puppet_agent\ dev\ package\ info\ unknown/ )
-      end
-
-      it 'calls out to the right method for solaris & returns what it gets' do
-        @platform = 'solaris-10-x86_64'
-        release_path_end_correct = 'release_path_end_correct_1'
-        release_file_correct = 'release_file_correct_1'
-        allow( host ).to receive( :solaris_puppet_agent_dev_package_info ) {
-          [release_path_end_correct, release_file_correct]
-        }
-
-        release_path_end, release_file = host.puppet_agent_dev_package_info(
-          'pa_collection', 'pa_version' )
-        expect( release_path_end ).to be === release_path_end_correct
-        expect( release_file ).to be === release_file_correct
-      end
-
-      it 'sets up sles|aix platforms correctly' do
-        @platform = 'sles-12-arch'
-        release_path_end, release_file = host.puppet_agent_dev_package_info(
-          'pa_collection', 'pa_version1' )
-        expect( release_path_end ).to be === "sles/12/pa_collection/arch"
-        expect( release_file ).to be === "puppet-agent-pa_version1-1.sles12.arch.rpm"
-      end
-
-      it 'sets up opensuse platforms correctly' do
-        @platform = 'opensuse-15-x86_64'
-        release_path_end, release_file = host.puppet_agent_dev_package_info(
-          'pa_collection', 'pa_version1' )
-        expect( release_path_end ).to be === "sles/15/pa_collection/x86_64"
-        expect( release_file ).to be === "puppet-agent-pa_version1-1.sles15.x86_64.rpm"
-      end
-
-      it 'sets the arch correctly on aix-power platforms' do
-        @platform = 'aix-6.1-power'
-        release_path_end, release_file = host.puppet_agent_dev_package_info(
-          'pa_collection', '6.0.0' )
-        expect( release_path_end ).to be === "aix/6.1/pa_collection/ppc"
-        expect( release_file ).to be === "puppet-agent-6.0.0-1.aix6.1.ppc.rpm"
-      end
-    end
-
-    describe '#pe_puppet_agent_promoted_package_info' do
-      context 'on ubuntu platforms' do
-        it 'splits the platform string version to get puppet-agent packages (format 9999)' do
-          @platform = 'ubuntu-9999-x42'
-          _, _, download_file = host.pe_puppet_agent_promoted_package_info(
-            'pa_collection'
-          )
-          expect( download_file ).to match( /-ubuntu-99\.99-x42/ )
-        end
-
-        it 'skips splitting the platform string version to get puppet-agent packages when unnecessary (format 99.99)' do
-          @platform = 'ubuntu-88.88-x63'
-          _, _, download_file = host.pe_puppet_agent_promoted_package_info(
-            'pa_collection'
-          )
-          expect( download_file ).to match( /-ubuntu-88\.88-x63/ )
-        end
+        { :platform => Beaker::Platform.new('el-vers-arch-extra') }
       end
     end
+    let(:host)    { make_host('name', options.merge(platform)) }
+    let(:opts)    { { :download_url => 'download_url' } }
 
     describe '#external_copy_base' do
-
       it 'returns /root in general' do
         copy_base = host.external_copy_base
-        expect( copy_base ).to be === '/root'
+        expect(copy_base).to be === '/root'
       end
 
       it 'returns /root if solaris but not version 10' do
         @platform = 'solaris-11-arch'
         copy_base = host.external_copy_base
-        expect( copy_base ).to be === '/root'
+        expect(copy_base).to be === '/root'
       end
 
       it 'returns / if on a solaris 10 platform' do
         @platform = 'solaris-10-arch'
         copy_base = host.external_copy_base
-        expect( copy_base ).to be === '/'
+        expect(copy_base).to be === '/'
       end
     end
 
     describe '#determine_ssh_server' do
       it 'returns :openssh' do
-        expect( host.determine_ssh_server ).to be === :openssh
+        expect(host.determine_ssh_server).to be === :openssh
       end
     end
 
     describe '#validate_setup' do
-
       it 'does nothing for non cisco_nexus-7 platforms' do
         @platform = 'el-7-x86_64'
         validate_test = host.validate_setup
-        expect( validate_test ).to be_nil
+        expect(validate_test).to be_nil
       end
     end
   end

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

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Beaker
   describe Windows::Exec do
     class WindowsExecTest
-      include Unix::Exec
       include Windows::Exec
 
       def initialize(hash, logger)
@@ -18,30 +17,29 @@ 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) { WindowsExecTest.new(opts, logger) }
 
     describe '#prepend_commands' do
       it 'sets spacing correctly if both parts are defined' do
-        allow( instance ).to receive( :is_cygwin? ).and_return( true )
-        command_str = instance.prepend_commands( 'command', 'pants', { :cmd_exe => true } )
-        expect( command_str ).to be === 'cmd.exe /c pants'
+        allow(instance).to receive(:is_cygwin?).and_return(true)
+        command_str = instance.prepend_commands('command', 'pants', { :cmd_exe => true })
+        expect(command_str).to be === 'cmd.exe /c pants'
       end
 
       it 'sets spacing empty if one is not supplied' do
-        allow( instance ).to receive( :is_cygwin? ).and_return( true )
-        command_str = instance.prepend_commands( 'command', 'pants' )
-        expect( command_str ).to be === 'pants'
+        allow(instance).to receive(:is_cygwin?).and_return(true)
+        command_str = instance.prepend_commands('command', 'pants')
+        expect(command_str).to be === 'pants'
       end
 
       it 'does not use cmd.exe by default' do
-        allow( instance ).to receive( :is_cygwin? ).and_return( true )
-        command_str = instance.prepend_commands( 'pants' )
-        expect( command_str ).not_to match( /cmd\.exe/ )
+        allow(instance).to receive(:is_cygwin?).and_return(true)
+        command_str = instance.prepend_commands('pants')
+        expect(command_str).not_to match(/cmd\.exe/)
       end
     end
 
@@ -55,27 +53,27 @@ module Beaker
 
     describe '#reboot' do
       it 'invokes the correct command on the host' do
-        expect( Beaker::Command ).to receive( :new ).with( /^shutdown \/f \/r \/t 0 \/d p:4:1 \/c "Beaker::Host reboot command issued"/ ).and_return( :foo )
-        expect( instance ).to receive( :exec ).with( :foo, :reset_connection => true )
-        expect( instance ).to receive( :sleep )
+        expect(Beaker::Command).to receive(:new).with(/^shutdown \/f \/r \/t 0 \/d p:4:1 \/c "Beaker::Host reboot command issued"/).and_return(:foo)
+        expect(instance).to receive(:exec).with(:foo, :reset_connection => true)
+        expect(instance).to receive(:sleep)
         instance.reboot
       end
     end
 
     describe '#cygwin_installed?' do
-      let(:response) { double( 'response' ) }
+      let(:response) { double('response') }
 
       it 'uses cygcheck to see if cygwin is installed' do
-        expect( Beaker::Command ).to receive(:new).with("cygcheck --check-setup cygwin").and_return(:foo)
-        expect( instance ).to receive( :exec ).with(:foo, :accept_all_exit_codes => true).and_return(response)
-        expect( response ).to receive(:stdout).and_return('cygwin OK')
+        expect(Beaker::Command).to receive(:new).with("cygcheck --check-setup cygwin").and_return(:foo)
+        expect(instance).to receive(:exec).with(:foo, :accept_all_exit_codes => true).and_return(response)
+        expect(response).to receive(:stdout).and_return('cygwin OK')
         expect(instance.cygwin_installed?).to eq(true)
       end
 
       it 'returns false when unable to find matching text' do
-        expect( Beaker::Command ).to receive(:new).with("cygcheck --check-setup cygwin").and_return(:foo)
-        expect( instance ).to receive( :exec ).with(:foo, :accept_all_exit_codes => true).and_return(response)
-        expect( response ).to receive(:stdout).and_return('No matching text')
+        expect(Beaker::Command).to receive(:new).with("cygcheck --check-setup cygwin").and_return(:foo)
+        expect(instance).to receive(:exec).with(:foo, :accept_all_exit_codes => true).and_return(response)
+        expect(response).to receive(:stdout).and_return('No matching text')
         expect(instance.cygwin_installed?).to eq(false)
       end
     end
@@ -85,15 +83,15 @@ module Beaker
       let(:destination) { '/destination/path/of/content' }
 
       it 'rm first' do
-        expect( instance ).to receive(:execute).with("rm -rf #{destination}").and_return(0)
-        expect( instance ).to receive(:execute).with("mv \"#{origin}\" \"#{destination}\"").and_return(0)
-        expect( instance.mv(origin, destination) ).to be === 0
-
+        # only defined on unix/pswindows
+        expect(instance).to receive(:rm_rf).with(destination).and_return("rm -rf #{destination}")
+        expect(instance).to receive(:execute).with("mv \"#{origin}\" \"#{destination}\"").and_return(0)
+        expect(instance.mv(origin, destination)).to be === 0
       end
 
       it 'does not rm' do
-         expect( instance ).to receive(:execute).with("mv \"#{origin}\" \"#{destination}\"").and_return(0)
-         expect( instance.mv(origin, destination, false) ).to be === 0
+        expect(instance).to receive(:execute).with("mv \"#{origin}\" \"#{destination}\"").and_return(0)
+        expect(instance.mv(origin, destination, false)).to be === 0
       end
     end
 
@@ -106,23 +104,23 @@ module Beaker
       end
 
       it 'accepts Pathname arguments' do
-        expect( instance ).to receive(:exec).with(having_attributes(command: "mkdir -p #{path}"), anything).and_return(result)
+        expect(instance).to receive(:exec).with(having_attributes(command: "mkdir -p #{path}"), anything).and_return(result)
         expect(instance.mkdir_p(Pathname.new(path))).to eq(true)
       end
 
       it 'omits quotes if the path starts with ~ and does not contain spaces' do
-        expect( instance ).to receive(:exec).with(having_attributes(command: "mkdir -p #{path}"), anything).and_return(result)
+        expect(instance).to receive(:exec).with(having_attributes(command: "mkdir -p #{path}"), anything).and_return(result)
         expect(instance.mkdir_p(path)).to eq(true)
       end
 
       it 'double quotes paths containing spaces' do
-        expect( instance ).to receive(:exec).with(having_attributes(command: "mkdir -p \"~/.foo bar\""), anything).and_return(result)
+        expect(instance).to receive(:exec).with(having_attributes(command: "mkdir -p \"~/.foo bar\""), anything).and_return(result)
         expect(instance.mkdir_p("~/.foo bar")).to eq(true)
       end
 
       it 'returns false if the command failed' do
         result.exit_code = 1
-        expect( instance ).to receive(:exec).with(having_attributes(command: "mkdir -p #{path}"), anything).and_return(result)
+        expect(instance).to receive(:exec).with(having_attributes(command: "mkdir -p #{path}"), anything).and_return(result)
         expect(instance.mkdir_p(path)).to eq(false)
       end
     end

data/spec/beaker/host/windows/file_spec.rb

@@ -6,38 +6,37 @@ module Beaker
     let(:group) { 'somegroup' }
     let(:path) { 'C:\Foo\Bar' }
     let(:newpath) { '/Foo/Bar' }
-    let(:host)    { make_host( 'name', { :platform => 'windows' } ) }
-
+    let(:host)    { make_host('name', { :platform => 'windows' }) }
 
     describe '#chown' do
       it 'calls cygpath first' do
-        expect( host ).to receive( :execute ).with( "cygpath -u #{path}" )
-        expect( host ).to receive( :execute ).with( /chown/ )
+        expect(host).to receive(:execute).with("cygpath -u #{path}")
+        expect(host).to receive(:execute).with(/chown/)
 
-        host.chown( user, path )
+        host.chown(user, path)
       end
 
       it 'passes cleaned path to super' do
-        allow_any_instance_of( Windows::Host ).to receive( :execute ).with( /cygpath/ ).and_return( newpath )
-        expect_any_instance_of( Unix::Host ).to receive( :chown ).with( user, newpath , true)
+        allow_any_instance_of(Windows::Host).to receive(:execute).with(/cygpath/).and_return(newpath)
+        expect_any_instance_of(Unix::Host).to receive(:chown).with(user, newpath, true)
 
-        host.chown( user, path, true )
+        host.chown(user, path, true)
       end
     end
 
     describe '#chgrp' do
       it 'calls cygpath first' do
-        expect( host ).to receive( :execute ).with( "cygpath -u #{path}" ).and_return( path )
-        expect( host ).to receive( :execute ).with( "chgrp #{group} #{path}" )
+        expect(host).to receive(:execute).with("cygpath -u #{path}").and_return(path)
+        expect(host).to receive(:execute).with("chgrp #{group} #{path}")
 
-        host.chgrp( group, path )
+        host.chgrp(group, path)
       end
 
       it 'passes cleaned path to super' do
-        allow_any_instance_of( Windows::Host ).to receive( :execute ).with( /cygpath/ ).and_return( newpath )
-        expect_any_instance_of( Unix::Host ).to receive( :chgrp ).with( group, newpath , true)
+        allow_any_instance_of(Windows::Host).to receive(:execute).with(/cygpath/).and_return(newpath)
+        expect_any_instance_of(Unix::Host).to receive(:chgrp).with(group, newpath, true)
 
-        host.chgrp( group, path, true )
+        host.chgrp(group, path, true)
       end
     end
 
@@ -45,10 +44,10 @@ module Beaker
       let(:result) { Beaker::Result.new(host, 'ls') }
 
       it 'calls cygpath first' do
-        expect( host ).to receive( :execute ).with( "cygpath -u #{path}" ).and_return( path )
-        expect( host ).to receive( :execute ).with( "ls -ld #{path}" )
+        expect(host).to receive(:execute).with("cygpath -u #{path}").and_return(path)
+        expect(host).to receive(:execute).with("ls -ld #{path}")
 
-        host.ls_ld( path )
+        host.ls_ld(path)
       end
     end
 
@@ -78,9 +77,9 @@ module Beaker
 
       it 'raises if the server can not be recognized' do
         allow(host).to receive(:determine_ssh_server).and_return(:unknown)
-        expect {
+        expect do
           host.scp_path(path)
-        }.to raise_error(ArgumentError, "windows/file.rb:scp_path: ssh server not recognized: 'unknown'")
+        end.to raise_error(ArgumentError, "windows/file.rb:scp_path: ssh server not recognized: 'unknown'")
       end
     end
   end

data/spec/beaker/host/windows/group_spec.rb

@@ -8,32 +8,31 @@ module Beaker
 
     let(:instance) { WindowsGroupTest.new }
     let(:result) { double(:result, :stdout => group_list_output) }
-    let(:group_list_output) do <<-EOS
+    let(:group_list_output) do
+      <<~EOS
+        Name=Foo
 
 
-Name=Foo
-
-
-Name=Bar6
+        Name=Bar6
 
 
       EOS
     end
 
     def add_group(group_name)
-      group_list_output << <<-EOS
-Name=#{group_name}
+      group_list_output << <<~EOS
+        Name=#{group_name}
 
 
       EOS
     end
 
     before do
-      expect( instance ).to receive(:execute).with(/wmic group where/).and_yield(result)
+      expect(instance).to receive(:execute).with(/wmic group where/).and_yield(result)
     end
 
     it "gets a group_list" do
-      expect(instance.group_list).to eql(["Foo", "Bar6"])
+      expect(instance.group_list).to eql(%w[Foo Bar6])
     end
 
     it "gets groups with spaces" do
@@ -41,15 +40,14 @@ Name=#{group_name}
       expect(instance.group_list).to eql(["Foo", "Bar6", "With Spaces"])
     end
 
-
     it "gets groups with dashes" do
       add_group("With-Dashes")
-      expect(instance.group_list).to eql(["Foo", "Bar6", "With-Dashes"])
+      expect(instance.group_list).to eql(%w[Foo Bar6 With-Dashes])
     end
 
     it "gets groups with underscores" do
       add_group("With_Underscores")
-      expect(instance.group_list).to eql(["Foo", "Bar6", "With_Underscores"])
+      expect(instance.group_list).to eql(%w[Foo Bar6 With_Underscores])
     end
   end
 end

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

@@ -19,32 +19,29 @@ 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) { WindowsPkgTest.new(opts, logger) }
 
     describe '#install_package' do
       before do
-        allow( instance ).to receive( :identify_windows_architecture )
+        allow(instance).to receive(:identify_windows_architecture)
       end
 
       context 'cygwin does not exist' do
         before do
-          allow( instance ).to receive( :check_for_command ).and_return( false )
+          allow(instance).to receive(:check_for_command).and_return(false)
         end
 
         it 'curls the SSL URL for cygwin\'s installer' do
-          allow(  instance ).to receive( :execute ).with( /^setup\-x86/     ).ordered
-          instance.install_package( 'curl' )
+          allow(instance).to receive(:execute).with(/^setup\-x86/).ordered
+          instance.install_package('curl')
         end
-
       end
     end
-
   end
 end

data/spec/beaker/host/windows/user_spec.rb

@@ -5,66 +5,60 @@ class WindowsUserTest
 end
 
 describe WindowsUserTest do
-  let( :wmic_output ) do <<-EOS
+  let(:wmic_output) do
+    <<~EOS
+      Name=Administrator
 
 
 
 
-Name=Administrator
 
+      Name=bob foo
 
 
 
 
-Name=bob foo
 
+      Name=bob-dash
 
 
 
 
-Name=bob-dash
 
+      Name=bob.foo
 
 
 
 
-Name=bob.foo
 
+      Name=cyg_server
 
 
 
 
-Name=cyg_server
 
 
 
 
-
-
-
-
-EOS
+    EOS
   end
-  let( :command )  { 'cmd /c echo "" | wmic useraccount where localaccount="true" get name /format:value' }
-  let( :host ) { double.as_null_object }
-  let( :result ) { Beaker::Result.new( host, command ) }
+  let(:command) { 'cmd /c echo "" | wmic useraccount where localaccount="true" get name /format:value' }
+  let(:host) { double.as_null_object }
+  let(:result) { Beaker::Result.new(host, command) }
 
   describe '#user_list' do
-
     it 'returns user names list correctly' do
       result.stdout = wmic_output
-      expect( subject ).to receive( :execute ).with( command ).and_yield(result)
-      expect( subject.user_list ).to be === ['Administrator', 'bob foo', 'bob-dash', 'bob.foo', 'cyg_server']
+      expect(subject).to receive(:execute).with(command).and_yield(result)
+      expect(subject.user_list).to be === ['Administrator', 'bob foo', 'bob-dash', 'bob.foo', 'cyg_server']
     end
 
     it 'yields correctly with the result object' do
       result.stdout = wmic_output
-      expect( subject ).to receive( :execute ).and_yield(result)
-      subject.user_list { |result|
-        expect( result.stdout ).to be === wmic_output
-      }
+      expect(subject).to receive(:execute).and_yield(result)
+      subject.user_list do |result|
+        expect(result.stdout).to be === wmic_output
+      end
     end
-
   end
-
 end