chef 14.2.0 → 14.3.37

data/spec/unit/provider/package/homebrew_spec.rb

@@ -173,16 +173,16 @@ describe Chef::Provider::Package::Homebrew do
   describe "brew" do
     before do
       expect(provider).to receive(:find_homebrew_uid).and_return(homebrew_uid)
-      expect(Etc).to receive(:getpwuid).with(homebrew_uid).and_return(OpenStruct.new(:name => "name", :dir => "/"))
+      expect(Etc).to receive(:getpwuid).with(homebrew_uid).and_return(OpenStruct.new(name: "name", dir: "/"))
     end
 
     it "passes a single to the brew command and return stdout" do
-      allow(provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "zombo"))
+      allow(provider).to receive(:shell_out!).and_return(OpenStruct.new(stdout: "zombo"))
       expect(provider.brew).to eql("zombo")
     end
 
     it "takes multiple arguments as an array" do
-      allow(provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "homestarrunner"))
+      allow(provider).to receive(:shell_out!).and_return(OpenStruct.new(stdout: "homestarrunner"))
       expect(provider.brew("info", "opts", "bananas")).to eql("homestarrunner")
     end
 
@@ -190,7 +190,7 @@ describe Chef::Provider::Package::Homebrew do
       let(:new_resource) { Chef::Resource::Package.new("emacs") }
 
       it "does not try to read homebrew_user from Package, which does not have it" do
-        allow(provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "zombo"))
+        allow(provider).to receive(:shell_out!).and_return(OpenStruct.new(stdout: "zombo"))
         expect(provider.brew).to eql("zombo")
       end
     end

data/spec/unit/provider/package/ips_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Bryan McLellan <btm@chef.io>
-# Copyright:: Copyright 2012-2017, Chef Software Inc.
+# Copyright:: Copyright 2012-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -35,125 +35,125 @@ describe Chef::Provider::Package::Ips do
   def local_output
     stdin  = StringIO.new
     stdout = ""
-    stderr = <<-PKG_STATUS
-pkg: info: no packages matching the following patterns you specified are
-installed on the system.  Try specifying -r to query remotely:
+    stderr = <<~PKG_STATUS
+      pkg: info: no packages matching the following patterns you specified are
+      installed on the system.  Try specifying -r to query remotely:
 
-   crypto/gnupg
+         crypto/gnupg
 PKG_STATUS
-    OpenStruct.new(:stdout => stdout, :stdin => stdin, :stderr => stderr, :status => @status, :exitstatus => 1)
+    OpenStruct.new(stdout: stdout, stdin: stdin, stderr: stderr, status: @status, exitstatus: 1)
   end
 
   def remote_output
-    stdout = <<-PKG_STATUS
-          Name: security/sudo
-       Summary: sudo - authority delegation tool
-         State: Not Installed
-     Publisher: omnios
-       Version: 1.8.4.1 (1.8.4p1)
- Build Release: 5.11
-        Branch: 0.151002
-Packaging Date: April  1, 2012 05:55:52 PM
-          Size: 2.57 MB
-          FMRI: pkg://omnios/security/sudo@1.8.4.1,5.11-0.151002:20120401T175552Z
+    stdout = <<~PKG_STATUS
+                Name: security/sudo
+             Summary: sudo - authority delegation tool
+               State: Not Installed
+           Publisher: omnios
+             Version: 1.8.4.1 (1.8.4p1)
+       Build Release: 5.11
+              Branch: 0.151002
+      Packaging Date: April  1, 2012 05:55:52 PM
+                Size: 2.57 MB
+                FMRI: pkg://omnios/security/sudo@1.8.4.1,5.11-0.151002:20120401T175552Z
 PKG_STATUS
     stdin = StringIO.new
     stderr = ""
-    OpenStruct.new(:stdout => stdout, :stdin => stdin, :stderr => stderr, :status => @status, :exitstatus => 0)
+    OpenStruct.new(stdout: stdout, stdin: stdin, stderr: stderr, status: @status, exitstatus: 0)
   end
 
   context "when loading current resource" do
     it "should create a current resource with the name of the new_resource" do
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
       expect(Chef::Resource::IpsPackage).to receive(:new).and_return(@current_resource)
       @provider.load_current_resource
     end
 
     it "should set the current resources package name to the new resources package name" do
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
       @provider.load_current_resource
       expect(@current_resource.package_name).to eq(@new_resource.package_name)
     end
 
     it "should run pkg info with the package name" do
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
       @provider.load_current_resource
     end
 
     it "should set the installed version to nil on the current resource if package state is not installed" do
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
       @provider.load_current_resource
       expect(@current_resource.version).to be_nil
     end
 
     it "should set the installed version if package has one" do
       local = local_output
-      local.stdout = <<-INSTALLED
-          Name: crypto/gnupg
-       Summary: GNU Privacy Guard
-   Description: A complete and free implementation of the OpenPGP Standard as
-                defined by RFC4880.
-      Category: Applications/System Utilities
-         State: Installed
-     Publisher: solaris
-       Version: 2.0.17
- Build Release: 5.11
-        Branch: 0.175.0.0.0.2.537
-Packaging Date: October 19, 2011 09:14:50 AM
-          Size: 8.07 MB
-          FMRI: pkg://solaris/crypto/gnupg@2.0.17,5.11-0.175.0.0.0.2.537:20111019T091450Z
+      local.stdout = <<~INSTALLED
+                  Name: crypto/gnupg
+               Summary: GNU Privacy Guard
+           Description: A complete and free implementation of the OpenPGP Standard as
+                        defined by RFC4880.
+              Category: Applications/System Utilities
+                 State: Installed
+             Publisher: solaris
+               Version: 2.0.17
+         Build Release: 5.11
+                Branch: 0.175.0.0.0.2.537
+        Packaging Date: October 19, 2011 09:14:50 AM
+                  Size: 8.07 MB
+                  FMRI: pkg://solaris/crypto/gnupg@2.0.17,5.11-0.175.0.0.0.2.537:20111019T091450Z
 INSTALLED
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
       @provider.load_current_resource
       expect(@current_resource.version).to eq("2.0.17")
     end
 
     it "should return the current resource" do
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote_output)
       expect(@provider.load_current_resource).to eql(@current_resource)
     end
   end
 
   context "when installing a package" do
     it "should run pkg install with the package name and version" do
-      expect(@provider).to receive(:shell_out!).with("pkg", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900)
       @provider.install_package("crypto/gnupg", "2.0.17")
     end
 
     it "should run pkg install with the package name and version and options if specified" do
-      expect(@provider).to receive(:shell_out!).with("pkg", "--no-refresh", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "--no-refresh", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900)
       @new_resource.options "--no-refresh"
       @provider.install_package("crypto/gnupg", "2.0.17")
     end
 
     it "raises an error if package fails to install" do
-      expect(@provider).to receive(:shell_out!).with("pkg", "--no-refresh", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "--no-refresh", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900).and_raise(Mixlib::ShellOut::ShellCommandFailed)
       @new_resource.options("--no-refresh")
       expect { @provider.install_package("crypto/gnupg", "2.0.17") }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
 
     it "should not include the human-readable version in the candidate_version" do
       remote = remote_output
-      remote.stdout = <<-PKG_STATUS
-          Name: security/sudo
-       Summary: sudo - authority delegation tool
-         State: Not Installed
-     Publisher: omnios
-       Version: 1.8.4.1 (1.8.4p1)
- Build Release: 5.11
-        Branch: 0.151002
-Packaging Date: April  1, 2012 05:55:52 PM
-          Size: 2.57 MB
-          FMRI: pkg://omnios/security/sudo@1.8.4.1,5.11-0.151002:20120401T175552Z
+      remote.stdout = <<~PKG_STATUS
+                  Name: security/sudo
+               Summary: sudo - authority delegation tool
+                 State: Not Installed
+             Publisher: omnios
+               Version: 1.8.4.1 (1.8.4p1)
+         Build Release: 5.11
+                Branch: 0.151002
+        Packaging Date: April  1, 2012 05:55:52 PM
+                  Size: 2.57 MB
+                  FMRI: pkg://omnios/security/sudo@1.8.4.1,5.11-0.151002:20120401T175552Z
 PKG_STATUS
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote)
       @provider.load_current_resource
       expect(@current_resource.version).to be_nil
       expect(@provider.candidate_version).to eql("1.8.4.1")
@@ -161,40 +161,40 @@ PKG_STATUS
 
     it "should not upgrade the package if it is already installed" do
       local = local_output
-      local.stdout = <<-INSTALLED
-          Name: crypto/gnupg
-       Summary: GNU Privacy Guard
-   Description: A complete and free implementation of the OpenPGP Standard as
-                defined by RFC4880.
-      Category: Applications/System Utilities
-         State: Installed
-     Publisher: solaris
-       Version: 2.0.17
- Build Release: 5.11
-        Branch: 0.175.0.0.0.2.537
-Packaging Date: October 19, 2011 09:14:50 AM
-          Size: 8.07 MB
-          FMRI: pkg://solaris/crypto/gnupg@2.0.17,5.11-0.175.0.0.0.2.537:20111019T091450Z
+      local.stdout = <<~INSTALLED
+                  Name: crypto/gnupg
+               Summary: GNU Privacy Guard
+           Description: A complete and free implementation of the OpenPGP Standard as
+                        defined by RFC4880.
+              Category: Applications/System Utilities
+                 State: Installed
+             Publisher: solaris
+               Version: 2.0.17
+         Build Release: 5.11
+                Branch: 0.175.0.0.0.2.537
+        Packaging Date: October 19, 2011 09:14:50 AM
+                  Size: 8.07 MB
+                  FMRI: pkg://solaris/crypto/gnupg@2.0.17,5.11-0.175.0.0.0.2.537:20111019T091450Z
 INSTALLED
       remote = remote_output
-      remote.stdout = <<-REMOTE
-          Name: crypto/gnupg
-       Summary: GNU Privacy Guard
-   Description: A complete and free implementation of the OpenPGP Standard as
-                defined by RFC4880.
-      Category: Applications/System Utilities
-         State: Not Installed
-     Publisher: solaris
-       Version: 2.0.18
- Build Release: 5.11
-        Branch: 0.175.0.0.0.2.537
-Packaging Date: October 19, 2011 09:14:50 AM
-          Size: 8.07 MB
-          FMRI: pkg://solaris/crypto/gnupg@2.0.18,5.11-0.175.0.0.0.2.537:20111019T091450Z
+      remote.stdout = <<~REMOTE
+                  Name: crypto/gnupg
+               Summary: GNU Privacy Guard
+           Description: A complete and free implementation of the OpenPGP Standard as
+                        defined by RFC4880.
+              Category: Applications/System Utilities
+                 State: Not Installed
+             Publisher: solaris
+               Version: 2.0.18
+         Build Release: 5.11
+                Branch: 0.175.0.0.0.2.537
+        Packaging Date: October 19, 2011 09:14:50 AM
+                  Size: 8.07 MB
+                  FMRI: pkg://solaris/crypto/gnupg@2.0.18,5.11-0.175.0.0.0.2.537:20111019T091450Z
 REMOTE
 
-      expect(@provider).to receive(:shell_out).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local)
-      expect(@provider).to receive(:shell_out!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote)
+      expect(@provider).to receive(:shell_out_compacted).with("pkg", "info", @new_resource.package_name, timeout: 900).and_return(local)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "info", "-r", @new_resource.package_name, timeout: 900).and_return(remote)
       expect(@provider).to receive(:install_package).exactly(0).times
       @provider.run_action(:install)
     end
@@ -205,7 +205,7 @@ REMOTE
       end
 
       it "should run pkg install with the --accept flag" do
-        expect(@provider).to receive(:shell_out).with("pkg", "install", "-q", "--accept", "crypto/gnupg@2.0.17", timeout: 900).and_return(local_output)
+        expect(@provider).to receive(:shell_out_compacted!).with("pkg", "install", "-q", "--accept", "crypto/gnupg@2.0.17", timeout: 900).and_return(local_output)
         @provider.install_package("crypto/gnupg", "2.0.17")
       end
     end
@@ -213,19 +213,19 @@ REMOTE
 
   context "when upgrading a package" do
     it "should run pkg install with the package name and version" do
-      expect(@provider).to receive(:shell_out).with("pkg", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900).and_return(local_output)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "install", "-q", "crypto/gnupg@2.0.17", timeout: 900).and_return(local_output)
       @provider.upgrade_package("crypto/gnupg", "2.0.17")
     end
   end
 
   context "when uninstalling a package" do
     it "should run pkg uninstall with the package name and version" do
-      expect(@provider).to receive(:shell_out!).with("pkg", "uninstall", "-q", "crypto/gnupg@2.0.17", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "uninstall", "-q", "crypto/gnupg@2.0.17", timeout: 900)
       @provider.remove_package("crypto/gnupg", "2.0.17")
     end
 
     it "should run pkg uninstall with the package name and version and options if specified" do
-      expect(@provider).to receive(:shell_out!).with("pkg", "--no-refresh", "uninstall", "-q", "crypto/gnupg@2.0.17", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("pkg", "--no-refresh", "uninstall", "-q", "crypto/gnupg@2.0.17", timeout: 900)
       @new_resource.options "--no-refresh"
       @provider.remove_package("crypto/gnupg", "2.0.17")
     end

data/spec/unit/provider/package/macports_spec.rb

@@ -70,33 +70,33 @@ describe Chef::Provider::Package::Macports do
 
   describe "current_installed_version" do
     it "should return the current version if the package is installed" do
-      stdout = <<EOF
-The following ports are currently installed:
-  openssl @0.9.8k_0 (active)
+      stdout = <<~EOF
+        The following ports are currently installed:
+          openssl @0.9.8k_0 (active)
 EOF
 
-      status = double(:stdout => stdout, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).and_return(status)
+      status = double(stdout: stdout, exitstatus: 0)
+      expect(@provider).to receive(:shell_out_compacted).and_return(status)
       expect(@provider.current_installed_version).to eq("0.9.8k_0")
     end
 
     it "should return nil if a package is not currently installed" do
-      status = double(:stdout => "       \n", :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).and_return(status)
+      status = double(stdout: "       \n", exitstatus: 0)
+      expect(@provider).to receive(:shell_out_compacted).and_return(status)
       expect(@provider.current_installed_version).to be_nil
     end
   end
 
   describe "macports_candidate_version" do
     it "should return the latest available version of a given package" do
-      status = double(:stdout => "version: 4.2.7\n", :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).and_return(status)
+      status = double(stdout: "version: 4.2.7\n", exitstatus: 0)
+      expect(@provider).to receive(:shell_out_compacted).and_return(status)
       expect(@provider.macports_candidate_version).to eq("4.2.7")
     end
 
     it "should return nil if there is no version for a given package" do
-      status = double(:stdout => "Error: port fadsfadsfads not found\n", :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).and_return(status)
+      status = double(stdout: "Error: port fadsfadsfads not found\n", exitstatus: 0)
+      expect(@provider).to receive(:shell_out_compacted).and_return(status)
       expect(@provider.macports_candidate_version).to be_nil
     end
   end
@@ -105,7 +105,7 @@ EOF
     it "should run the port install command with the correct version" do
       expect(@current_resource).to receive(:version).and_return("4.1.6")
       @provider.current_resource = @current_resource
-      expect(@provider).to receive(:shell_out!).with("port", "install", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "install", "zsh", "@4.2.7", timeout: 900)
 
       @provider.install_package("zsh", "4.2.7")
     end
@@ -113,7 +113,7 @@ EOF
     it "should not do anything if a package already exists with the same version" do
       expect(@current_resource).to receive(:version).and_return("4.2.7")
       @provider.current_resource = @current_resource
-      expect(@provider).not_to receive(:shell_out!)
+      expect(@provider).not_to receive(:shell_out_compacted!)
 
       @provider.install_package("zsh", "4.2.7")
     end
@@ -122,7 +122,7 @@ EOF
       expect(@current_resource).to receive(:version).and_return("4.1.6")
       @provider.current_resource = @current_resource
       @new_resource.options("-f")
-      expect(@provider).to receive(:shell_out!).with("port", "-f", "install", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "-f", "install", "zsh", "@4.2.7", timeout: 900)
 
       @provider.install_package("zsh", "4.2.7")
     end
@@ -130,36 +130,36 @@ EOF
 
   describe "purge_package" do
     it "should run the port uninstall command with the correct version" do
-      expect(@provider).to receive(:shell_out!).with("port", "uninstall", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "uninstall", "zsh", "@4.2.7", timeout: 900)
       @provider.purge_package("zsh", "4.2.7")
     end
 
     it "should purge the currently active version if no explicit version is passed in" do
-      expect(@provider).to receive(:shell_out!).with("port", "uninstall", "zsh", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "uninstall", "zsh", timeout: 900)
       @provider.purge_package("zsh", nil)
     end
 
     it "should add options to the port command when specified" do
       @new_resource.options("-f")
-      expect(@provider).to receive(:shell_out!).with("port", "-f", "uninstall", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "-f", "uninstall", "zsh", "@4.2.7", timeout: 900)
       @provider.purge_package("zsh", "4.2.7")
     end
   end
 
   describe "remove_package" do
     it "should run the port deactivate command with the correct version" do
-      expect(@provider).to receive(:shell_out!).with("port", "deactivate", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "deactivate", "zsh", "@4.2.7", timeout: 900)
       @provider.remove_package("zsh", "4.2.7")
     end
 
     it "should remove the currently active version if no explicit version is passed in" do
-      expect(@provider).to receive(:shell_out!).with("port", "deactivate", "zsh", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "deactivate", "zsh", timeout: 900)
       @provider.remove_package("zsh", nil)
     end
 
     it "should add options to the port command when specified" do
       @new_resource.options("-f")
-      expect(@provider).to receive(:shell_out!).with("port", "-f", "deactivate", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "-f", "deactivate", "zsh", "@4.2.7", timeout: 900)
       @provider.remove_package("zsh", "4.2.7")
     end
   end
@@ -169,7 +169,7 @@ EOF
       expect(@current_resource).to receive(:version).at_least(:once).and_return("4.1.6")
       @provider.current_resource = @current_resource
 
-      expect(@provider).to receive(:shell_out!).with("port", "upgrade", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "upgrade", "zsh", "@4.2.7", timeout: 900)
 
       @provider.upgrade_package("zsh", "4.2.7")
     end
@@ -177,7 +177,7 @@ EOF
     it "should not run the port upgrade command if the version is already installed" do
       expect(@current_resource).to receive(:version).at_least(:once).and_return("4.2.7")
       @provider.current_resource = @current_resource
-      expect(@provider).not_to receive(:shell_out!)
+      expect(@provider).not_to receive(:shell_out_compacted!)
 
       @provider.upgrade_package("zsh", "4.2.7")
     end
@@ -195,7 +195,7 @@ EOF
       expect(@current_resource).to receive(:version).at_least(:once).and_return("4.1.6")
       @provider.current_resource = @current_resource
 
-      expect(@provider).to receive(:shell_out!).with("port", "-f", "upgrade", "zsh", "@4.2.7", timeout: 900)
+      expect(@provider).to receive(:shell_out_compacted!).with("port", "-f", "upgrade", "zsh", "@4.2.7", timeout: 900)
 
       @provider.upgrade_package("zsh", "4.2.7")
     end