chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

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

@@ -28,7 +28,7 @@ describe Chef::Provider::Package::Ips do
     @run_context = Chef::RunContext.new(@node, {}, @events)
     @new_resource = Chef::Resource::Package.new("crypto/gnupg", @run_context)
     @current_resource = Chef::Resource::Package.new("crypto/gnupg", @run_context)
-    Chef::Resource::Package.stub(:new).and_return(@current_resource)
+    allow(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
     @provider = Chef::Provider::Package::Ips.new(@new_resource, @run_context)
   end
 
@@ -65,30 +65,30 @@ PKG_STATUS
 
   context "when loading current resource" do
     it "should create a current resource with the name of the new_resource" do
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
-      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
+      expect(Chef::Resource::Package).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
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
       @provider.load_current_resource
-      @current_resource.package_name.should == @new_resource.package_name
+      expect(@current_resource.package_name).to eq(@new_resource.package_name)
     end
 
     it "should run pkg info with the package name" do
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").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
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
       @provider.load_current_resource
-      @current_resource.version.should be_nil
+      expect(@current_resource.version).to be_nil
     end
 
     it "should set the installed version if package has one" do
@@ -108,28 +108,28 @@ 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
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
       @provider.load_current_resource
-      @current_resource.version.should == "2.0.17"
+      expect(@current_resource.version).to eq("2.0.17")
     end
 
     it "should return the current resource" do
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote_output)
-      @provider.load_current_resource.should eql(@current_resource)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").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
-      @provider.should_receive(:shell_out).with("pkg install -q crypto/gnupg@2.0.17")
+      expect(@provider).to receive(:shell_out).with("pkg install -q crypto/gnupg@2.0.17")
       @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
-      @provider.should_receive(:shell_out).with("pkg --no-refresh install -q crypto/gnupg@2.0.17")
-      @new_resource.stub(:options).and_return("--no-refresh")
+      expect(@provider).to receive(:shell_out).with("pkg --no-refresh install -q crypto/gnupg@2.0.17")
+      allow(@new_resource).to receive(:options).and_return("--no-refresh")
       @provider.install_package("crypto/gnupg", "2.0.17")
     end
 
@@ -147,11 +147,11 @@ 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
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local_output)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote)
       @provider.load_current_resource
-      @current_resource.version.should be_nil
-      @provider.candidate_version.should eql("1.8.4.1")
+      expect(@current_resource.version).to be_nil
+      expect(@provider.candidate_version).to eql("1.8.4.1")
     end
 
     it "should not upgrade the package if it is already installed" do
@@ -188,20 +188,20 @@ Packaging Date: October 19, 2011 09:14:50 AM
           FMRI: pkg://solaris/crypto/gnupg@2.0.18,5.11-0.175.0.0.0.2.537:20111019T091450Z
 REMOTE
 
-      @provider.should_receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local)
-      @provider.should_receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote)
+      expect(@provider).to receive(:shell_out).with("pkg info #{@new_resource.package_name}").and_return(local)
+      expect(@provider).to receive(:shell_out!).with("pkg info -r #{@new_resource.package_name}").and_return(remote)
       @provider.load_current_resource
-      @provider.should_receive(:install_package).exactly(0).times
+      expect(@provider).to receive(:install_package).exactly(0).times
       @provider.action_install
     end
 
     context "when accept_license is true" do
       before do
-        @new_resource.stub(:accept_license).and_return(true)
+        allow(@new_resource).to receive(:accept_license).and_return(true)
       end
 
       it "should run pkg install with the --accept flag" do
-        @provider.should_receive(:shell_out).with("pkg install -q --accept crypto/gnupg@2.0.17")
+        expect(@provider).to receive(:shell_out).with("pkg install -q --accept crypto/gnupg@2.0.17")
         @provider.install_package("crypto/gnupg", "2.0.17")
       end
     end
@@ -209,20 +209,20 @@ REMOTE
 
   context "when upgrading a package" do
     it "should run pkg install with the package name and version" do
-      @provider.should_receive(:shell_out).with("pkg install -q crypto/gnupg@2.0.17")
+      expect(@provider).to receive(:shell_out).with("pkg install -q crypto/gnupg@2.0.17")
       @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
-      @provider.should_receive(:shell_out!).with("pkg uninstall -q crypto/gnupg@2.0.17")
+      expect(@provider).to receive(:shell_out!).with("pkg uninstall -q crypto/gnupg@2.0.17")
       @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
-      @provider.should_receive(:shell_out!).with("pkg --no-refresh uninstall -q crypto/gnupg@2.0.17")
-      @new_resource.stub(:options).and_return("--no-refresh")
+      expect(@provider).to receive(:shell_out!).with("pkg --no-refresh uninstall -q crypto/gnupg@2.0.17")
+      allow(@new_resource).to receive(:options).and_return("--no-refresh")
       @provider.remove_package("crypto/gnupg", "2.0.17")
     end
   end

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

@@ -27,7 +27,7 @@ describe Chef::Provider::Package::Macports do
     @current_resource = Chef::Resource::Package.new("zsh")
 
     @provider = Chef::Provider::Package::Macports.new(@new_resource, @run_context)
-    Chef::Resource::Package.stub(:new).and_return(@current_resource)
+    allow(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
 
     @status = double("Status", :exitstatus => 0)
     @stdin = StringIO.new
@@ -38,91 +38,91 @@ describe Chef::Provider::Package::Macports do
 
   describe "load_current_resource" do
     it "should create a current resource with the name of the new_resource" do
-      @provider.should_receive(:current_installed_version).and_return(nil)
-      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+      expect(@provider).to receive(:current_installed_version).and_return(nil)
+      expect(@provider).to receive(:macports_candidate_version).and_return("4.2.7")
 
       @provider.load_current_resource
-      @provider.current_resource.name.should == "zsh"
+      expect(@provider.current_resource.name).to eq("zsh")
     end
 
     it "should create a current resource with the version if the package is installed" do
-      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
-      @provider.should_receive(:current_installed_version).and_return("4.2.7")
+      expect(@provider).to receive(:macports_candidate_version).and_return("4.2.7")
+      expect(@provider).to receive(:current_installed_version).and_return("4.2.7")
 
       @provider.load_current_resource
-      @provider.candidate_version.should == "4.2.7"
+      expect(@provider.candidate_version).to eq("4.2.7")
     end
 
     it "should create a current resource with a nil version if the package is not installed" do
-      @provider.should_receive(:current_installed_version).and_return(nil)
-      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+      expect(@provider).to receive(:current_installed_version).and_return(nil)
+      expect(@provider).to receive(:macports_candidate_version).and_return("4.2.7")
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
 
     it "should set a candidate version if one exists" do
-      @provider.should_receive(:current_installed_version).and_return(nil)
-      @provider.should_receive(:macports_candidate_version).and_return("4.2.7")
+      expect(@provider).to receive(:current_installed_version).and_return(nil)
+      expect(@provider).to receive(:macports_candidate_version).and_return("4.2.7")
       @provider.load_current_resource
-      @provider.candidate_version.should == "4.2.7"
+      expect(@provider.candidate_version).to eq("4.2.7")
     end
   end
 
   describe "current_installed_version" do
     it "should return the current version if the package is installed" do
-      @stdout.should_receive(:read).and_return(<<EOF
+      expect(@stdout).to receive(:read).and_return(<<EOF
 The following ports are currently installed:
   openssl @0.9.8k_0 (active)
 EOF
       )
 
-      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.current_installed_version.should == "0.9.8k_0"
+      expect(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).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
-      @stdout.should_receive(:read).and_return("       \n")
-      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.current_installed_version.should be_nil
+      expect(@stdout).to receive(:read).and_return("       \n")
+      expect(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).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
-      @stdout.should_receive(:read).and_return("version: 4.2.7\n")
-      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.macports_candidate_version.should == "4.2.7"
+      expect(@stdout).to receive(:read).and_return("version: 4.2.7\n")
+      expect(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).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
-      @stdout.should_receive(:read).and_return("Error: port fadsfadsfads not found\n")
-      @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.macports_candidate_version.should be_nil
+      expect(@stdout).to receive(:read).and_return("Error: port fadsfadsfads not found\n")
+      expect(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider.macports_candidate_version).to be_nil
     end
   end
 
   describe "install_package" do
     it "should run the port install command with the correct version" do
-      @current_resource.should_receive(:version).and_return("4.1.6")
+      expect(@current_resource).to receive(:version).and_return("4.1.6")
       @provider.current_resource = @current_resource
-      @provider.should_receive(:shell_out!).with("port install zsh @4.2.7")
+      expect(@provider).to receive(:shell_out!).with("port install zsh @4.2.7")
 
       @provider.install_package("zsh", "4.2.7")
     end
 
     it "should not do anything if a package already exists with the same version" do
-      @current_resource.should_receive(:version).and_return("4.2.7")
+      expect(@current_resource).to receive(:version).and_return("4.2.7")
       @provider.current_resource = @current_resource
-      @provider.should_not_receive(:shell_out!)
+      expect(@provider).not_to receive(:shell_out!)
 
       @provider.install_package("zsh", "4.2.7")
     end
 
     it "should add options to the port command when specified" do
-      @current_resource.should_receive(:version).and_return("4.1.6")
+      expect(@current_resource).to receive(:version).and_return("4.1.6")
       @provider.current_resource = @current_resource
-      @new_resource.stub(:options).and_return("-f")
-      @provider.should_receive(:shell_out!).with("port -f install zsh @4.2.7")
+      allow(@new_resource).to receive(:options).and_return("-f")
+      expect(@provider).to receive(:shell_out!).with("port -f install zsh @4.2.7")
 
       @provider.install_package("zsh", "4.2.7")
     end
@@ -130,72 +130,72 @@ EOF
 
   describe "purge_package" do
     it "should run the port uninstall command with the correct version" do
-      @provider.should_receive(:shell_out!).with("port uninstall zsh @4.2.7")
+      expect(@provider).to receive(:shell_out!).with("port uninstall zsh @4.2.7")
       @provider.purge_package("zsh", "4.2.7")
     end
 
     it "should purge the currently active version if no explicit version is passed in" do
-      @provider.should_receive(:shell_out!).with("port uninstall zsh")
+      expect(@provider).to receive(:shell_out!).with("port uninstall zsh")
       @provider.purge_package("zsh", nil)
     end
 
     it "should add options to the port command when specified" do
-      @new_resource.stub(:options).and_return("-f")
-      @provider.should_receive(:shell_out!).with("port -f uninstall zsh @4.2.7")
+      allow(@new_resource).to receive(:options).and_return("-f")
+      expect(@provider).to receive(:shell_out!).with("port -f uninstall zsh @4.2.7")
       @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
-      @provider.should_receive(:shell_out!).with("port deactivate zsh @4.2.7")
+      expect(@provider).to receive(:shell_out!).with("port deactivate zsh @4.2.7")
       @provider.remove_package("zsh", "4.2.7")
     end
 
     it "should remove the currently active version if no explicit version is passed in" do
-      @provider.should_receive(:shell_out!).with("port deactivate zsh")
+      expect(@provider).to receive(:shell_out!).with("port deactivate zsh")
       @provider.remove_package("zsh", nil)
     end
 
     it "should add options to the port command when specified" do
-      @new_resource.stub(:options).and_return("-f")
-      @provider.should_receive(:shell_out!).with("port -f deactivate zsh @4.2.7")
+      allow(@new_resource).to receive(:options).and_return("-f")
+      expect(@provider).to receive(:shell_out!).with("port -f deactivate zsh @4.2.7")
       @provider.remove_package("zsh", "4.2.7")
     end
   end
 
   describe "upgrade_package" do
     it "should run the port upgrade command with the correct version" do
-      @current_resource.should_receive(:version).at_least(:once).and_return("4.1.6")
+      expect(@current_resource).to receive(:version).at_least(:once).and_return("4.1.6")
       @provider.current_resource = @current_resource
 
-      @provider.should_receive(:shell_out!).with("port upgrade zsh @4.2.7")
+      expect(@provider).to receive(:shell_out!).with("port upgrade zsh @4.2.7")
 
       @provider.upgrade_package("zsh", "4.2.7")
     end
 
     it "should not run the port upgrade command if the version is already installed" do
-      @current_resource.should_receive(:version).at_least(:once).and_return("4.2.7")
+      expect(@current_resource).to receive(:version).at_least(:once).and_return("4.2.7")
       @provider.current_resource = @current_resource
-      @provider.should_not_receive(:shell_out!)
+      expect(@provider).not_to receive(:shell_out!)
 
       @provider.upgrade_package("zsh", "4.2.7")
     end
 
     it "should call install_package if the package isn't currently installed" do
-      @current_resource.should_receive(:version).at_least(:once).and_return(nil)
+      expect(@current_resource).to receive(:version).at_least(:once).and_return(nil)
       @provider.current_resource = @current_resource
-      @provider.should_receive(:install_package).and_return(true)
+      expect(@provider).to receive(:install_package).and_return(true)
 
       @provider.upgrade_package("zsh", "4.2.7")
     end
 
     it "should add options to the port command when specified" do
-      @new_resource.stub(:options).and_return("-f")
-      @current_resource.should_receive(:version).at_least(:once).and_return("4.1.6")
+      allow(@new_resource).to receive(:options).and_return("-f")
+      expect(@current_resource).to receive(:version).at_least(:once).and_return("4.1.6")
       @provider.current_resource = @current_resource
 
-      @provider.should_receive(:shell_out!).with("port -f upgrade zsh @4.2.7")
+      expect(@provider).to receive(:shell_out!).with("port -f upgrade zsh @4.2.7")
 
       @provider.upgrade_package("zsh", "4.2.7")
     end

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

@@ -28,8 +28,8 @@ describe Chef::Provider::Package::Pacman do
 
     @status = double("Status", :exitstatus => 0)
     @provider = Chef::Provider::Package::Pacman.new(@new_resource, @run_context)
-    Chef::Resource::Package.stub(:new).and_return(@current_resource)
-    @provider.stub(:popen4).and_return(@status)
+    allow(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
+    allow(@provider).to receive(:popen4).and_return(@status)
     @stdin = StringIO.new
     @stdout = StringIO.new(<<-ERR)
 error: package "nano" not found
@@ -40,29 +40,29 @@ ERR
 
   describe "when determining the current package state" do
     it "should create a current resource with the name of the new_resource" do
-      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      expect(Chef::Resource::Package).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
-      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      expect(@current_resource).to receive(:package_name).with(@new_resource.package_name)
       @provider.load_current_resource
     end
 
     it "should run pacman query with the package name" do
-      @provider.should_receive(:popen4).with("pacman -Qi #{@new_resource.package_name}").and_return(@status)
+      expect(@provider).to receive(:popen4).with("pacman -Qi #{@new_resource.package_name}").and_return(@status)
       @provider.load_current_resource
     end
 
     it "should read stdout on pacman" do
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @stdout.should_receive(:each).and_return(true)
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@stdout).to receive(:each).and_return(true)
       @provider.load_current_resource
     end
 
     it "should set the installed version to nil on the current resource if pacman installed version not exists" do
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @current_resource.should_receive(:version).with(nil).and_return(true)
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@current_resource).to receive(:version).with(nil).and_return(true)
       @provider.load_current_resource
     end
 
@@ -88,19 +88,16 @@ Install Reason : Explicitly installed
 Install Script : Yes
 Description    : Pico editor clone with enhancements
 PACMAN
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @current_resource.version.should == "2.2.2-1"
+      expect(@current_resource.version).to eq("2.2.2-1")
     end
 
     it "should set the candidate version if pacman has one" do
-      @stdout.stub(:each).and_yield("core/nano 2.2.3-1 (base)").
-                            and_yield("    Pico editor clone with enhancements").
-                            and_yield("community/nanoblogger 3.4.1-1").
-                            and_yield("    NanoBlogger is a small weblog engine written in Bash for the command line")
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      allow(@stdout).to receive(:each).and_yield("core nano 2.2.3-1")
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.candidate_version.should eql("2.2.3-1")
+      expect(@provider.candidate_version).to eql("2.2.3-1")
     end
 
     it "should use pacman.conf to determine valid repo names for package versions" do
@@ -122,46 +119,45 @@ Include = /etc/pacman.d/mirrorlist
 Include = /etc/pacman.d/mirrorlist
 PACMAN_CONF
 
-      ::File.stub(:exists?).with("/etc/pacman.conf").and_return(true)
-      ::File.stub(:read).with("/etc/pacman.conf").and_return(@pacman_conf)
-      @stdout.stub(:each).and_yield("customrepo/nano 1.2.3-4").
-                            and_yield("    My custom package")
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      allow(::File).to receive(:exists?).with("/etc/pacman.conf").and_return(true)
+      allow(::File).to receive(:read).with("/etc/pacman.conf").and_return(@pacman_conf)
+      allow(@stdout).to receive(:each).and_yield("customrepo nano 1.2.3-4")
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
 
       @provider.load_current_resource
-      @provider.candidate_version.should eql("1.2.3-4")
+      expect(@provider.candidate_version).to eql("1.2.3-4")
     end
 
     it "should raise an exception if pacman fails" do
-      @status.should_receive(:exitstatus).and_return(2)
-      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+      expect(@status).to receive(:exitstatus).and_return(2)
+      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should not raise an exception if pacman succeeds" do
-      @status.should_receive(:exitstatus).and_return(0)
-      lambda { @provider.load_current_resource }.should_not raise_error
+      expect(@status).to receive(:exitstatus).and_return(0)
+      expect { @provider.load_current_resource }.not_to raise_error
     end
 
     it "should raise an exception if pacman does not return a candidate version" do
-      @stdout.stub(:each).and_yield("")
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+      allow(@stdout).to receive(:each).and_yield("")
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect { @provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should return the current resouce" do
-      @provider.load_current_resource.should eql(@current_resource)
+      expect(@provider.load_current_resource).to eql(@current_resource)
     end
   end
 
   describe Chef::Provider::Package::Pacman, "install_package" do
     it "should run pacman install with the package name and version" do
-      @provider.should_receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar nano")
+      expect(@provider).to receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar nano")
       @provider.install_package("nano", "1.0")
     end
 
     it "should run pacman install with the package name and version and options if specified" do
-      @provider.should_receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar --debug nano")
-      @new_resource.stub(:options).and_return("--debug")
+      expect(@provider).to receive(:shell_out!).with("pacman --sync --noconfirm --noprogressbar --debug nano")
+      allow(@new_resource).to receive(:options).and_return("--debug")
 
       @provider.install_package("nano", "1.0")
     end
@@ -169,20 +165,20 @@ PACMAN_CONF
 
   describe Chef::Provider::Package::Pacman, "upgrade_package" do
     it "should run install_package with the name and version" do
-      @provider.should_receive(:install_package).with("nano", "1.0")
+      expect(@provider).to receive(:install_package).with("nano", "1.0")
       @provider.upgrade_package("nano", "1.0")
     end
   end
 
   describe Chef::Provider::Package::Pacman, "remove_package" do
     it "should run pacman remove with the package name" do
-      @provider.should_receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar nano")
+      expect(@provider).to receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar nano")
       @provider.remove_package("nano", "1.0")
     end
 
     it "should run pacman remove with the package name and options if specified" do
-      @provider.should_receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar --debug nano")
-      @new_resource.stub(:options).and_return("--debug")
+      expect(@provider).to receive(:shell_out!).with("pacman --remove --noconfirm --noprogressbar --debug nano")
+      allow(@new_resource).to receive(:options).and_return("--debug")
 
       @provider.remove_package("nano", "1.0")
     end
@@ -190,7 +186,7 @@ PACMAN_CONF
 
   describe Chef::Provider::Package::Pacman, "purge_package" do
     it "should run remove_package with the name and version" do
-      @provider.should_receive(:remove_package).with("nano", "1.0")
+      expect(@provider).to receive(:remove_package).with("nano", "1.0")
       @provider.purge_package("nano", "1.0")
     end