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

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

@@ -31,7 +31,7 @@ describe Chef::Provider::Package::SmartOS, "load_current_resource" do
 
 	  @status = double("Status", :exitstatus => 0)
 		@provider = Chef::Provider::Package::SmartOS.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)
 		@stdin = StringIO.new
 		@stdout = "varnish-2.1.5nb2\n"
 		@stderr = StringIO.new
@@ -42,28 +42,28 @@ describe Chef::Provider::Package::SmartOS, "load_current_resource" do
 	describe "when loading current resource" do
 
     it "should create a current resource with the name of the new_resource" do
-			@provider.should_receive(:shell_out!).and_return(@shell_out)
-			Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+			expect(@provider).to receive(:shell_out!).and_return(@shell_out)
+			expect(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
 			@provider.load_current_resource
     end
 
 		it "should set the current resource package name" do
-			@provider.should_receive(:shell_out!).and_return(@shell_out)
-			@current_resource.should_receive(:package_name).with(@new_resource.package_name)
+			expect(@provider).to receive(:shell_out!).and_return(@shell_out)
+			expect(@current_resource).to receive(:package_name).with(@new_resource.package_name)
 			@provider.load_current_resource
 		end
 
 		it "should set the installed version if it is installed" do
-		  @provider.should_receive(:shell_out!).and_return(@shell_out)
+		  expect(@provider).to receive(:shell_out!).and_return(@shell_out)
 			@provider.load_current_resource
-			@current_resource.version.should == "2.1.5nb2"
+			expect(@current_resource.version).to eq("2.1.5nb2")
 	  end
 
 		it "should set the installed version to nil if it's not installed" do
 			out = OpenStruct.new(:stdout => nil)
-			@provider.should_receive(:shell_out!).and_return(out)
+			expect(@provider).to receive(:shell_out!).and_return(out)
 			@provider.load_current_resource
-			@current_resource.version.should == nil
+			expect(@current_resource.version).to eq(nil)
 		end
 
 
@@ -72,18 +72,18 @@ describe Chef::Provider::Package::SmartOS, "load_current_resource" do
   describe "candidate_version" do
     it "should return the candidate_version variable if already setup" do
       @provider.candidate_version = "2.1.1"
-      @provider.should_not_receive(:shell_out!)
+      expect(@provider).not_to receive(:shell_out!)
       @provider.candidate_version
     end
 
     it "should lookup the candidate_version if the variable is not already set" do
       search = double()
-      search.should_receive(:each_line).
+      expect(search).to receive(:each_line).
         and_yield("something-varnish-1.1.1  something varnish like\n").
         and_yield("varnish-2.3.4 actual varnish\n")
       @shell_out = double('shell_out!', :stdout => search)
-      @provider.should_receive(:shell_out!).with('/opt/local/bin/pkgin se varnish', :env => nil, :returns => [0,1]).and_return(@shell_out)
-      @provider.candidate_version.should == "2.3.4"
+      expect(@provider).to receive(:shell_out!).with('/opt/local/bin/pkgin se varnish', :env => nil, :returns => [0,1]).and_return(@shell_out)
+      expect(@provider.candidate_version).to eq("2.3.4")
     end
   end
 
@@ -91,8 +91,8 @@ describe Chef::Provider::Package::SmartOS, "load_current_resource" do
 
 		it "run pkgin and install the package" do
 			out = OpenStruct.new(:stdout => nil)
-      @provider.should_receive(:shell_out!).with("/opt/local/sbin/pkg_info -E \"varnish*\"", {:env => nil, :returns=>[0,1]}).and_return(@shell_out)
-      @provider.should_receive(:shell_out!).with("/opt/local/bin/pkgin -y install varnish-2.1.5nb2", {:env=>nil}).and_return(out)
+      expect(@provider).to receive(:shell_out!).with("/opt/local/sbin/pkg_info -E \"varnish*\"", {:env => nil, :returns=>[0,1]}).and_return(@shell_out)
+      expect(@provider).to receive(:shell_out!).with("/opt/local/bin/pkgin -y install varnish-2.1.5nb2", {:env=>nil}).and_return(out)
       @provider.load_current_resource
       @provider.install_package("varnish", "2.1.5nb2")
 		end

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

@@ -27,7 +27,7 @@ describe Chef::Provider::Package::Solaris do
     @new_resource.source("/tmp/bash.pkg")
 
     @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-    ::File.stub(:exists?).and_return(true)
+    allow(::File).to receive(:exists?).and_return(true)
   end
 
   describe "assessing the current package status" do
@@ -50,119 +50,119 @@ PKGINFO
     end
 
     it "should create a current resource with the name of new_resource" do
-      @provider.stub(:popen4).and_return(@status)
+      allow(@provider).to receive(:popen4).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.name.should == "SUNWbash"
+      expect(@provider.current_resource.name).to eq("SUNWbash")
     end
 
     it "should set the current reource package name to the new resource package name" do
-      @provider.stub(:popen4).and_return(@status)
+      allow(@provider).to receive(:popen4).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == "SUNWbash"
+      expect(@provider.current_resource.package_name).to eq("SUNWbash")
     end
 
     it "should raise an exception if a source is supplied but not found" do
-      @provider.stub(:popen4).and_return(@status)
-      ::File.stub(:exists?).and_return(false)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      allow(::File).to receive(:exists?).and_return(false)
       @provider.define_resource_requirements
       @provider.load_current_resource
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Package)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should get the source package version from pkginfo if provided" do
       @stdout = StringIO.new(@pkginfo)
       @stdin, @stderr = StringIO.new, StringIO.new
-      @provider.should_receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.should_receive(:popen4).with("pkginfo -l SUNWbash").and_return(@status)
+      expect(@provider).to receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("pkginfo -l SUNWbash").and_return(@status)
       @provider.load_current_resource
 
-      @provider.current_resource.package_name.should == "SUNWbash"
-      @new_resource.version.should == "11.10.0,REV=2005.01.08.05.16"
+      expect(@provider.current_resource.package_name).to eq("SUNWbash")
+      expect(@new_resource.version).to eq("11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should return the current version installed if found by pkginfo" do
       @stdout = StringIO.new(@pkginfo)
       @stdin, @stderr = StringIO.new, StringIO.new
-      @provider.should_receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_return(@status)
-      @provider.should_receive(:popen4).with("pkginfo -l SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_return(@status)
+      expect(@provider).to receive(:popen4).with("pkginfo -l SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should == "11.10.0,REV=2005.01.08.05.16"
+      expect(@provider.current_resource.version).to eq("11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should raise an exception if the source is not set but we are installing" do
       @new_resource = Chef::Resource::Package.new("SUNWbash")
       @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-      @provider.stub(:popen4).and_return(@status)
-      lambda { @provider.run_action(:install) }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should raise an exception if pkginfo fails to run" do
       @status = double("Status", :exitstatus => -1)
-      @provider.stub(:popen4).and_return(@status)
-      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should return a current resource with a nil version if the package is not found" do
       @stdout = StringIO.new
-      @provider.should_receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_return(@status)
-      @provider.should_receive(:popen4).with("pkginfo -l SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("pkginfo -l -d /tmp/bash.pkg SUNWbash").and_return(@status)
+      expect(@provider).to receive(:popen4).with("pkginfo -l SUNWbash").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
   end
 
   describe "candidate_version" do
     it "should return the candidate_version variable if already setup" do
       @provider.candidate_version = "11.10.0,REV=2005.01.08.05.16"
-      @provider.should_not_receive(:popen4)
+      expect(@provider).not_to receive(:popen4)
       @provider.candidate_version
     end
 
     it "should lookup the candidate_version if the variable is not already set" do
       @status = double("Status", :exitstatus => 0)
-      @provider.stub(:popen4).and_return(@status)
-      @provider.should_receive(:popen4)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect(@provider).to receive(:popen4)
       @provider.candidate_version
     end
 
     it "should throw and exception if the exitstatus is not 0" do
       @status = double("Status", :exitstatus => 1)
-      @provider.stub(:popen4).and_return(@status)
-      lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect { @provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
     end
 
   end
 
   describe "install and upgrade" do
     it "should run pkgadd -n -d with the package source to install" do
-      @provider.should_receive(:shell_out!).with("pkgadd -n -d /tmp/bash.pkg all")
+      expect(@provider).to receive(:shell_out!).with("pkgadd -n -d /tmp/bash.pkg all")
       @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should run pkgadd -n -d when the package is a path to install" do
       @new_resource = Chef::Resource::Package.new("/tmp/bash.pkg")
       @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-      @new_resource.source.should == "/tmp/bash.pkg"
-      @provider.should_receive(:shell_out!).with("pkgadd -n -d /tmp/bash.pkg all")
+      expect(@new_resource.source).to eq("/tmp/bash.pkg")
+      expect(@provider).to receive(:shell_out!).with("pkgadd -n -d /tmp/bash.pkg all")
       @provider.install_package("/tmp/bash.pkg", "11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should run pkgadd -n -a /tmp/myadmin -d with the package options -a /tmp/myadmin" do
-      @new_resource.stub(:options).and_return("-a /tmp/myadmin")
-      @provider.should_receive(:shell_out!).with("pkgadd -n -a /tmp/myadmin -d /tmp/bash.pkg all")
+      allow(@new_resource).to receive(:options).and_return("-a /tmp/myadmin")
+      expect(@provider).to receive(:shell_out!).with("pkgadd -n -a /tmp/myadmin -d /tmp/bash.pkg all")
       @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
   end
 
   describe "remove" do
     it "should run pkgrm -n to remove the package" do
-      @provider.should_receive(:shell_out!).with("pkgrm -n SUNWbash")
+      expect(@provider).to receive(:shell_out!).with("pkgrm -n SUNWbash")
       @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should run pkgrm -n -a /tmp/myadmin with options -a /tmp/myadmin" do
-      @new_resource.stub(:options).and_return("-a /tmp/myadmin")
-      @provider.should_receive(:shell_out!).with("pkgrm -n -a /tmp/myadmin SUNWbash")
+      allow(@new_resource).to receive(:options).and_return("-a /tmp/myadmin")
+      expect(@provider).to receive(:shell_out!).with("pkgrm -n -a /tmp/myadmin SUNWbash")
       @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
 

data/spec/unit/provider/package/windows/msi_spec.rb

@@ -37,15 +37,15 @@ describe Chef::Provider::Package::Windows::MSI, :windows_only do
 
   describe "installed_version" do
     it "returns the installed version" do
-      provider.stub(:get_product_property).and_return("{23170F69-40C1-2702-0920-000001000000}")
-      provider.stub(:get_installed_version).with("{23170F69-40C1-2702-0920-000001000000}").and_return("3.14159.1337.42")
+      allow(provider).to receive(:get_product_property).and_return("{23170F69-40C1-2702-0920-000001000000}")
+      allow(provider).to receive(:get_installed_version).with("{23170F69-40C1-2702-0920-000001000000}").and_return("3.14159.1337.42")
       expect(provider.installed_version).to eql("3.14159.1337.42")
     end
   end
 
   describe "package_version" do
     it "returns the version of a package" do
-      provider.stub(:get_product_property).with(/calculator.msi$/, "ProductVersion").and_return(42)
+      allow(provider).to receive(:get_product_property).with(/calculator.msi$/, "ProductVersion").and_return(42)
       expect(provider.package_version).to eql(42)
     end
   end

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

@@ -27,8 +27,8 @@ describe Chef::Provider::Package::Windows, :windows_only do
 
   describe "load_current_resource" do
     before(:each) do
-      Chef::Util::PathHelper.stub(:validate_path)
-      provider.stub(:package_provider).and_return(double('package_provider',
+      allow(Chef::Util::PathHelper).to receive(:validate_path)
+      allow(provider).to receive(:package_provider).and_return(double('package_provider',
           :installed_version => "1.0", :package_version => "2.0"))
     end
 
@@ -56,20 +56,20 @@ describe Chef::Provider::Package::Windows, :windows_only do
 
   describe "package_provider" do
     it "sets the package provider to MSI if the the installer type is :msi" do
-      provider.stub(:installer_type).and_return(:msi)
+      allow(provider).to receive(:installer_type).and_return(:msi)
       expect(provider.package_provider).to be_a(Chef::Provider::Package::Windows::MSI)
     end
 
     it "raises an error if the installer_type is unknown" do
-      provider.stub(:installer_type).and_return(:apt_for_windows)
+      allow(provider).to receive(:installer_type).and_return(:apt_for_windows)
       expect { provider.package_provider }.to raise_error
     end
   end
 
   describe "installer_type" do
     it "it returns @installer_type if it is set" do
-      provider.new_resource.installer_type("downeaster")
-      expect(provider.installer_type).to eql("downeaster")
+      provider.new_resource.installer_type(:downeaster)
+      expect(provider.installer_type).to eql(:downeaster)
     end
 
     it "sets installer_type to msi if the source ends in .msi" do

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

@@ -37,7 +37,7 @@ describe Chef::Provider::Package::Yum do
       :package_repository => "base",
       :disable_extra_repo_control => true
     )
-    Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+    allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
     @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
     @pid = double("PID")
   end
@@ -45,32 +45,32 @@ describe Chef::Provider::Package::Yum do
   describe "when loading the current system state" do
     it "should create a current resource with the name of the new_resource" do
       @provider.load_current_resource
-      @provider.current_resource.name.should == "cups"
+      expect(@provider.current_resource.name).to eq("cups")
     end
 
     it "should set the current resources package name to the new resources package name" do
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == "cups"
+      expect(@provider.current_resource.package_name).to eq("cups")
     end
 
     it "should set the installed version to nil on the current resource if no installed package" do
-      @yum_cache.stub(:installed_version).and_return(nil)
+      allow(@yum_cache).to receive(:installed_version).and_return(nil)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
 
     it "should set the installed version if yum has one" do
       @provider.load_current_resource
-      @provider.current_resource.version.should == "1.2.4-11.18.el5"
+      expect(@provider.current_resource.version).to eq("1.2.4-11.18.el5")
     end
 
     it "should set the candidate version if yum info has one" do
       @provider.load_current_resource
-      @provider.candidate_version.should eql("1.2.4-11.18.el5_2.3")
+      expect(@provider.candidate_version).to eql("1.2.4-11.18.el5_2.3")
     end
 
     it "should return the current resouce" do
-      @provider.load_current_resource.should eql(@provider.current_resource)
+      expect(@provider.load_current_resource).to eql(@provider.current_resource)
     end
 
     describe "when arch in package_name" do
@@ -79,11 +79,11 @@ describe Chef::Provider::Package::Yum do
         @yum_cache = double(
           'Chef::Provider::Yum::YumCache'
         )
-        @yum_cache.stub(:installed_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:installed_version) do |package_name, arch|
           # nothing installed for package_name/new_package_name
           nil
         end
-        @yum_cache.stub(:candidate_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:candidate_version) do |package_name, arch|
           if package_name == "testing.noarch" || package_name == "testing.more.noarch"
             nil
           # candidate for new_package_name
@@ -91,21 +91,21 @@ describe Chef::Provider::Package::Yum do
             "1.1"
           end
         end
-        @yum_cache.stub(:package_available?).and_return(true)
-        @yum_cache.stub(:disable_extra_repo_control).and_return(true)
-        Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+        allow(@yum_cache).to receive(:package_available?).and_return(true)
+        allow(@yum_cache).to receive(:disable_extra_repo_control).and_return(true)
+        allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing"
-        @provider.new_resource.arch.should == "noarch"
-        @provider.arch.should == "noarch"
+        expect(@provider.new_resource.package_name).to eq("testing")
+        expect(@provider.new_resource.arch).to eq("noarch")
+        expect(@provider.arch).to eq("noarch")
 
         @new_resource = Chef::Resource::YumPackage.new('testing.more.noarch')
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing.more"
-        @provider.new_resource.arch.should == "noarch"
-        @provider.arch.should == "noarch"
+        expect(@provider.new_resource.package_name).to eq("testing.more")
+        expect(@provider.new_resource.arch).to eq("noarch")
+        expect(@provider.arch).to eq("noarch")
       end
 
       it "should not set the arch when an existing package_name is found" do
@@ -113,7 +113,7 @@ describe Chef::Provider::Package::Yum do
         @yum_cache = double(
           'Chef::Provider::Yum::YumCache'
         )
-        @yum_cache.stub(:installed_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:installed_version) do |package_name, arch|
           # installed for package_name
           if package_name == "testing.beta3" || package_name == "testing.beta3.more"
             "1.1"
@@ -121,26 +121,26 @@ describe Chef::Provider::Package::Yum do
             nil
           end
         end
-        @yum_cache.stub(:candidate_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:candidate_version) do |package_name, arch|
           # no candidate for package_name/new_package_name
           nil
         end
-        @yum_cache.stub(:package_available?).and_return(true)
-        @yum_cache.stub(:disable_extra_repo_control).and_return(true)
-        Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+        allow(@yum_cache).to receive(:package_available?).and_return(true)
+        allow(@yum_cache).to receive(:disable_extra_repo_control).and_return(true)
+        allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         # annoying side effect of the fun stub'ing above
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing.beta3"
-        @provider.new_resource.arch.should == nil
-        @provider.arch.should == nil
+        expect(@provider.new_resource.package_name).to eq("testing.beta3")
+        expect(@provider.new_resource.arch).to eq(nil)
+        expect(@provider.arch).to eq(nil)
 
         @new_resource = Chef::Resource::YumPackage.new('testing.beta3.more')
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing.beta3.more"
-        @provider.new_resource.arch.should == nil
-        @provider.arch.should == nil
+        expect(@provider.new_resource.package_name).to eq("testing.beta3.more")
+        expect(@provider.new_resource.arch).to eq(nil)
+        expect(@provider.arch).to eq(nil)
       end
 
       it "should not set the arch when no existing package_name or new_package_name+new_arch is found" do
@@ -148,29 +148,29 @@ describe Chef::Provider::Package::Yum do
         @yum_cache = double(
           'Chef::Provider::Yum::YumCache'
         )
-        @yum_cache.stub(:installed_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:installed_version) do |package_name, arch|
           # nothing installed for package_name/new_package_name
           nil
         end
-        @yum_cache.stub(:candidate_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:candidate_version) do |package_name, arch|
           # no candidate for package_name/new_package_name
           nil
         end
-        @yum_cache.stub(:package_available?).and_return(true)
-        @yum_cache.stub(:disable_extra_repo_control).and_return(true)
-        Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+        allow(@yum_cache).to receive(:package_available?).and_return(true)
+        allow(@yum_cache).to receive(:disable_extra_repo_control).and_return(true)
+        allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing.beta3"
-        @provider.new_resource.arch.should == nil
-        @provider.arch.should == nil
+        expect(@provider.new_resource.package_name).to eq("testing.beta3")
+        expect(@provider.new_resource.arch).to eq(nil)
+        expect(@provider.arch).to eq(nil)
 
         @new_resource = Chef::Resource::YumPackage.new('testing.beta3.more')
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing.beta3.more"
-        @provider.new_resource.arch.should == nil
-        @provider.arch.should == nil
+        expect(@provider.new_resource.package_name).to eq("testing.beta3.more")
+        expect(@provider.new_resource.arch).to eq(nil)
+        expect(@provider.arch).to eq(nil)
       end
 
       it "should ensure it doesn't clobber an existing arch if passed" do
@@ -179,11 +179,11 @@ describe Chef::Provider::Package::Yum do
         @yum_cache = double(
           'Chef::Provider::Yum::YumCache'
         )
-         @yum_cache.stub(:installed_version) do |package_name, arch|
+         allow(@yum_cache).to receive(:installed_version) do |package_name, arch|
            # nothing installed for package_name/new_package_name
          nil
         end
-        @yum_cache.stub(:candidate_version) do |package_name, arch|
+        allow(@yum_cache).to receive(:candidate_version) do |package_name, arch|
           if package_name == "testing.noarch"
             nil
           # candidate for new_package_name
@@ -191,43 +191,43 @@ describe Chef::Provider::Package::Yum do
             "1.1"
           end
         end.and_return("something")
-        @yum_cache.stub(:package_available?).and_return(true)
-        @yum_cache.stub(:disable_extra_repo_control).and_return(true)
-        Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+        allow(@yum_cache).to receive(:package_available?).and_return(true)
+        allow(@yum_cache).to receive(:disable_extra_repo_control).and_return(true)
+        allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
         @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
         @provider.load_current_resource
-        @provider.new_resource.package_name.should == "testing.i386"
-        @provider.new_resource.arch.should == "x86_64"
+        expect(@provider.new_resource.package_name).to eq("testing.i386")
+        expect(@provider.new_resource.arch).to eq("x86_64")
       end
     end
 
     it "should flush the cache if :before is true" do
-      @new_resource.stub(:flush_cache).and_return({:after => false, :before => true})
-      @yum_cache.should_receive(:reload).once
+      allow(@new_resource).to receive(:flush_cache).and_return({:after => false, :before => true})
+      expect(@yum_cache).to receive(:reload).once
       @provider.load_current_resource
     end
 
     it "should flush the cache if :before is false" do
-      @new_resource.stub(:flush_cache).and_return({:after => false, :before => false})
-      @yum_cache.should_not_receive(:reload)
+      allow(@new_resource).to receive(:flush_cache).and_return({:after => false, :before => false})
+      expect(@yum_cache).not_to receive(:reload)
       @provider.load_current_resource
     end
 
     it "should detect --enablerepo or --disablerepo when passed among options, collect them preserving order and notify the yum cache" do
-      @new_resource.stub(:options).and_return("--stuff --enablerepo=foo --otherthings --disablerepo=a,b,c  --enablerepo=bar")
-      @yum_cache.should_receive(:enable_extra_repo_control).with("--enablerepo=foo --disablerepo=a,b,c --enablerepo=bar")
+      allow(@new_resource).to receive(:options).and_return("--stuff --enablerepo=foo --otherthings --disablerepo=a,b,c  --enablerepo=bar")
+      expect(@yum_cache).to receive(:enable_extra_repo_control).with("--enablerepo=foo --disablerepo=a,b,c --enablerepo=bar")
       @provider.load_current_resource
     end
 
     it "should let the yum cache know extra repos are disabled if --enablerepo or --disablerepo aren't among options" do
-      @new_resource.stub(:options).and_return("--stuff --otherthings")
-      @yum_cache.should_receive(:disable_extra_repo_control)
+      allow(@new_resource).to receive(:options).and_return("--stuff --otherthings")
+      expect(@yum_cache).to receive(:disable_extra_repo_control)
       @provider.load_current_resource
     end
 
     it "should let the yum cache know extra repos are disabled if options aren't set" do
-      @new_resource.stub(:options).and_return(nil)
-      @yum_cache.should_receive(:disable_extra_repo_control)
+      allow(@new_resource).to receive(:options).and_return(nil)
+      expect(@yum_cache).to receive(:disable_extra_repo_control)
       @provider.load_current_resource
     end
 
@@ -242,12 +242,12 @@ describe Chef::Provider::Package::Yum do
         :version_available? => true,
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       pkg = Chef::Provider::Package::Yum::RPMPackage.new("test-package", "1.2.4-11.18.el5", "x86_64", [])
-      @yum_cache.should_receive(:packages_from_require).and_return([pkg])
+      expect(@yum_cache).to receive(:packages_from_require).and_return([pkg])
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      @new_resource.package_name.should == "test-package"
+      expect(@new_resource.package_name).to eq("test-package")
     end
 
     it "should search provides if package name can't be found, warn about multiple matches, but use the first one" do
@@ -261,14 +261,14 @@ describe Chef::Provider::Package::Yum do
         :version_available? => true,
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       pkg_x = Chef::Provider::Package::Yum::RPMPackage.new("test-package-x", "1.2.4-11.18.el5", "x86_64", [])
       pkg_y = Chef::Provider::Package::Yum::RPMPackage.new("test-package-y", "1.2.6-11.3.el5", "i386", [])
-      @yum_cache.should_receive(:packages_from_require).and_return([pkg_x, pkg_y])
-      Chef::Log.should_receive(:warn).exactly(1).times.with(%r{matched multiple Provides})
+      expect(@yum_cache).to receive(:packages_from_require).and_return([pkg_x, pkg_y])
+      expect(Chef::Log).to receive(:warn).exactly(1).times.with(%r{matched multiple Provides})
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      @new_resource.package_name.should == "test-package-x"
+      expect(@new_resource.package_name).to eq("test-package-x")
     end
 
     it "should search provides if no package is available - if no match in installed provides then load the complete set" do
@@ -282,9 +282,9 @@ describe Chef::Provider::Package::Yum do
         :version_available? => true,
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
-      @yum_cache.should_receive(:packages_from_require).twice.and_return([])
-      @yum_cache.should_receive(:reload_provides)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
+      expect(@yum_cache).to receive(:packages_from_require).twice.and_return([])
+      expect(@yum_cache).to receive(:reload_provides)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
     end
@@ -300,14 +300,14 @@ describe Chef::Provider::Package::Yum do
         :version_available? => true,
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
-      @yum_cache.should_receive(:packages_from_require).once.and_return([])
-      @yum_cache.should_not_receive(:reload_provides)
+      expect(@yum_cache).to receive(:packages_from_require).once.and_return([])
+      expect(@yum_cache).not_to receive(:reload_provides)
       @new_resource.action(:remove)
       @provider.load_current_resource
-      @yum_cache.should_receive(:packages_from_require).once.and_return([])
-      @yum_cache.should_not_receive(:reload_provides)
+      expect(@yum_cache).to receive(:packages_from_require).once.and_return([])
+      expect(@yum_cache).not_to receive(:reload_provides)
       @new_resource.action(:purge)
       @provider.load_current_resource
     end
@@ -324,27 +324,27 @@ describe Chef::Provider::Package::Yum do
         :version_available? => true,
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
-      @yum_cache.should_receive(:packages_from_require).twice.and_return([])
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
+      expect(@yum_cache).to receive(:packages_from_require).twice.and_return([])
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      @new_resource.package_name.should == "cups"
+      expect(@new_resource.package_name).to eq("cups")
     end
   end
 
   describe "when installing a package" do
     it "should run yum install with the package name and version" do
       @provider.load_current_resource
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install emacs-1.0"
       )
       @provider.install_package("emacs", "1.0")
     end
 
     it "should run yum localinstall if given a path to an rpm" do
-      @new_resource.stub(:source).and_return("/tmp/emacs-21.4-20.el5.i386.rpm")
-      @provider.should_receive(:yum_command).with(
+      allow(@new_resource).to receive(:source).and_return("/tmp/emacs-21.4-20.el5.i386.rpm")
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y localinstall /tmp/emacs-21.4-20.el5.i386.rpm"
       )
       @provider.install_package("emacs", "21.4-20.el5")
@@ -352,10 +352,10 @@ describe Chef::Provider::Package::Yum do
 
     it "should run yum localinstall if given a path to an rpm as the package" do
       @new_resource = Chef::Resource::Package.new("/tmp/emacs-21.4-20.el5.i386.rpm")
-      ::File.stub(:exists?).and_return(true)
+      allow(::File).to receive(:exists?).and_return(true)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
-      @new_resource.source.should == "/tmp/emacs-21.4-20.el5.i386.rpm"
-      @provider.should_receive(:yum_command).with(
+      expect(@new_resource.source).to eq("/tmp/emacs-21.4-20.el5.i386.rpm")
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y localinstall /tmp/emacs-21.4-20.el5.i386.rpm"
       )
       @provider.install_package("/tmp/emacs-21.4-20.el5.i386.rpm", "21.4-20.el5")
@@ -363,9 +363,9 @@ describe Chef::Provider::Package::Yum do
 
     it "should run yum install with the package name, version and arch" do
       @provider.load_current_resource
-      @new_resource.stub(:arch).and_return("i386")
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(@new_resource).to receive(:arch).and_return("i386")
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install emacs-21.4-20.el5.i386"
       )
       @provider.install_package("emacs", "21.4-20.el5")
@@ -374,9 +374,9 @@ describe Chef::Provider::Package::Yum do
     it "installs the package with the options given in the resource" do
       @provider.load_current_resource
       @provider.candidate_version = '11'
-      @new_resource.stub(:options).and_return("--disablerepo epmd")
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(@new_resource).to receive(:options).and_return("--disablerepo epmd")
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y --disablerepo epmd install cups-11"
       )
       @provider.install_package(@new_resource.name, @provider.candidate_version)
@@ -393,13 +393,13 @@ describe Chef::Provider::Package::Yum do
         :version_available? => nil,
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
-      lambda { @provider.install_package("lolcats", "0.99") }.should raise_error(Chef::Exceptions::Package, %r{Version .* not found})
+      expect { @provider.install_package("lolcats", "0.99") }.to raise_error(Chef::Exceptions::Package, %r{Version .* not found})
     end
 
     it "should raise an exception if candidate version is older than the installed version and allow_downgrade is false" do
-      @new_resource.stub(:allow_downgrade).and_return(false)
+      allow(@new_resource).to receive(:allow_downgrade).and_return(false)
       @yum_cache = double(
         'Chef::Provider::Yum::YumCache',
         :reload_installed => true,
@@ -411,10 +411,10 @@ describe Chef::Provider::Package::Yum do
         :allow_multi_install => [ "kernel" ],
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      lambda { @provider.install_package("cups", "1.2.4-11.15.el5") }.should raise_error(Chef::Exceptions::Package, %r{is newer than candidate package})
+      expect { @provider.install_package("cups", "1.2.4-11.15.el5") }.to raise_error(Chef::Exceptions::Package, %r{is newer than candidate package})
     end
 
     it "should not raise an exception if candidate version is older than the installed version and the package is list in yum's installonlypkg option" do
@@ -430,17 +430,17 @@ describe Chef::Provider::Package::Yum do
         :package_repository => "base",
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      @provider.should_receive(:yum_command).with(
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install cups-1.2.4-11.15.el5"
       )
       @provider.install_package("cups", "1.2.4-11.15.el5")
     end
 
     it "should run yum downgrade if candidate version is older than the installed version and allow_downgrade is true" do
-      @new_resource.stub(:allow_downgrade).and_return(true)
+      allow(@new_resource).to receive(:allow_downgrade).and_return(true)
       @yum_cache = double(
         'Chef::Provider::Yum::YumCache',
         :reload_installed => true,
@@ -453,34 +453,34 @@ describe Chef::Provider::Package::Yum do
         :package_repository => "base",
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      @provider.should_receive(:yum_command).with(
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y downgrade cups-1.2.4-11.15.el5"
       )
       @provider.install_package("cups", "1.2.4-11.15.el5")
     end
 
     it "should run yum install then flush the cache if :after is true" do
-      @new_resource.stub(:flush_cache).and_return({:after => true, :before => false})
+      allow(@new_resource).to receive(:flush_cache).and_return({:after => true, :before => false})
       @provider.load_current_resource
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install emacs-1.0"
       )
-      @yum_cache.should_receive(:reload).once
+      expect(@yum_cache).to receive(:reload).once
       @provider.install_package("emacs", "1.0")
     end
 
     it "should run yum install then not flush the cache if :after is false" do
-      @new_resource.stub(:flush_cache).and_return({:after => false, :before => false})
+      allow(@new_resource).to receive(:flush_cache).and_return({:after => false, :before => false})
       @provider.load_current_resource
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install emacs-1.0"
       )
-      @yum_cache.should_not_receive(:reload)
+      expect(@yum_cache).not_to receive(:reload)
       @provider.install_package("emacs", "1.0")
     end
   end
@@ -489,8 +489,8 @@ describe Chef::Provider::Package::Yum do
     it "should run yum install if the package is installed and a version is given" do
       @provider.load_current_resource
       @provider.candidate_version = '11'
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install cups-11"
       )
       @provider.upgrade_package(@new_resource.name, @provider.candidate_version)
@@ -500,8 +500,8 @@ describe Chef::Provider::Package::Yum do
       @provider.load_current_resource
       @current_resource = Chef::Resource::Package.new('cups')
       @provider.candidate_version = '11'
-      Chef::Provider::Package::Yum::RPMUtils.stub(:rpmvercmp).and_return(-1)
-      @provider.should_receive(:yum_command).with(
+      allow(Chef::Provider::Package::Yum::RPMUtils).to receive(:rpmvercmp).and_return(-1)
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y install cups-11"
       )
       @provider.upgrade_package(@new_resource.name, @provider.candidate_version)
@@ -519,19 +519,19 @@ describe Chef::Provider::Package::Yum do
         :allow_multi_install => [ "kernel" ],
         :disable_extra_repo_control => true
       )
-      Chef::Provider::Package::Yum::YumCache.stub(:instance).and_return(@yum_cache)
+      allow(Chef::Provider::Package::Yum::YumCache).to receive(:instance).and_return(@yum_cache)
       @provider = Chef::Provider::Package::Yum.new(@new_resource, @run_context)
       @provider.load_current_resource
-      lambda { @provider.upgrade_package("cups", "1.2.4-11.15.el5") }.should raise_error(Chef::Exceptions::Package, %r{is newer than candidate package})
+      expect { @provider.upgrade_package("cups", "1.2.4-11.15.el5") }.to raise_error(Chef::Exceptions::Package, %r{is newer than candidate package})
     end
 
     # Test our little workaround, some crossover into Chef::Provider::Package territory
     it "should call action_upgrade in the parent if the current resource version is nil" do
-      @yum_cache.stub(:installed_version).and_return(nil)
+      allow(@yum_cache).to receive(:installed_version).and_return(nil)
       @provider.load_current_resource
       @current_resource = Chef::Resource::Package.new('cups')
       @provider.candidate_version = '11'
-      @provider.should_receive(:upgrade_package).with(
+      expect(@provider).to receive(:upgrade_package).with(
         "cups",
         "11"
       )
@@ -542,7 +542,7 @@ describe Chef::Provider::Package::Yum do
       @provider.load_current_resource
       @current_resource = Chef::Resource::Package.new('cups')
       @provider.candidate_version = nil
-      @provider.should_not_receive(:upgrade_package)
+      expect(@provider).not_to receive(:upgrade_package)
       @provider.action_upgrade
     end
 
@@ -550,7 +550,7 @@ describe Chef::Provider::Package::Yum do
       @provider.load_current_resource
       @current_resource = Chef::Resource::Package.new('cups')
       @provider.candidate_version = '11'
-      @provider.should_receive(:upgrade_package).with(
+      expect(@provider).to receive(:upgrade_package).with(
         "cups",
         "11"
       )
@@ -558,26 +558,26 @@ describe Chef::Provider::Package::Yum do
     end
 
     it "should not call action_upgrade in the parent if the candidate is older" do
-      @yum_cache.stub(:installed_version).and_return("12")
+      allow(@yum_cache).to receive(:installed_version).and_return("12")
       @provider.load_current_resource
       @current_resource = Chef::Resource::Package.new('cups')
       @provider.candidate_version = '11'
-      @provider.should_not_receive(:upgrade_package)
+      expect(@provider).not_to receive(:upgrade_package)
       @provider.action_upgrade
     end
   end
 
   describe "when removing a package" do
     it "should run yum remove with the package name" do
-      @provider.should_receive(:yum_command).with(
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y remove emacs-1.0"
       )
       @provider.remove_package("emacs", "1.0")
     end
 
     it "should run yum remove with the package name and arch" do
-      @new_resource.stub(:arch).and_return("x86_64")
-      @provider.should_receive(:yum_command).with(
+      allow(@new_resource).to receive(:arch).and_return("x86_64")
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y remove emacs-1.0.x86_64"
       )
       @provider.remove_package("emacs", "1.0")
@@ -586,7 +586,7 @@ describe Chef::Provider::Package::Yum do
 
   describe "when purging a package" do
     it "should run yum remove with the package name" do
-      @provider.should_receive(:yum_command).with(
+      expect(@provider).to receive(:yum_command).with(
         "yum -d0 -e0 -y remove emacs-1.0"
       )
       @provider.purge_package("emacs", "1.0")
@@ -596,8 +596,8 @@ describe Chef::Provider::Package::Yum do
   describe "when running yum" do
     it "should run yum once if it exits with a return code of 0" do
       @status = double("Status", :exitstatus => 0)
-      @provider.stub(:output_of_command).and_return([@status, "", ""])
-      @provider.should_receive(:output_of_command).once.with(
+      allow(@provider).to receive(:output_of_command).and_return([@status, "", ""])
+      expect(@provider).to receive(:output_of_command).once.with(
         "yum -d0 -e0 -y install emacs-1.0",
         {:timeout => Chef::Config[:yum_timeout]}
       )
@@ -606,34 +606,34 @@ describe Chef::Provider::Package::Yum do
 
     it "should run yum once if it exits with a return code > 0 and no scriptlet failures" do
       @status = double("Status", :exitstatus => 2)
-      @provider.stub(:output_of_command).and_return([@status, "failure failure", "problem problem"])
-      @provider.should_receive(:output_of_command).once.with(
+      allow(@provider).to receive(:output_of_command).and_return([@status, "failure failure", "problem problem"])
+      expect(@provider).to receive(:output_of_command).once.with(
         "yum -d0 -e0 -y install emacs-1.0",
         {:timeout => Chef::Config[:yum_timeout]}
       )
-      lambda { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.should raise_error(Chef::Exceptions::Exec)
+      expect { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.to raise_error(Chef::Exceptions::Exec)
     end
 
     it "should run yum once if it exits with a return code of 1 and %pre scriptlet failures" do
       @status = double("Status", :exitstatus => 1)
-      @provider.stub(:output_of_command).and_return([@status, "error: %pre(demo-1-1.el5.centos.x86_64) scriptlet failed, exit status 2", ""])
-      @provider.should_receive(:output_of_command).once.with(
+      allow(@provider).to receive(:output_of_command).and_return([@status, "error: %pre(demo-1-1.el5.centos.x86_64) scriptlet failed, exit status 2", ""])
+      expect(@provider).to receive(:output_of_command).once.with(
         "yum -d0 -e0 -y install emacs-1.0",
         {:timeout => Chef::Config[:yum_timeout]}
       )
       # will still raise an exception, can't stub out the subsequent call
-      lambda { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.should raise_error(Chef::Exceptions::Exec)
+      expect { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.to raise_error(Chef::Exceptions::Exec)
     end
 
     it "should run yum twice if it exits with a return code of 1 and %post scriptlet failures" do
       @status = double("Status", :exitstatus => 1)
-      @provider.stub(:output_of_command).and_return([@status, "error: %post(demo-1-1.el5.centos.x86_64) scriptlet failed, exit status 2", ""])
-      @provider.should_receive(:output_of_command).twice.with(
+      allow(@provider).to receive(:output_of_command).and_return([@status, "error: %post(demo-1-1.el5.centos.x86_64) scriptlet failed, exit status 2", ""])
+      expect(@provider).to receive(:output_of_command).twice.with(
         "yum -d0 -e0 -y install emacs-1.0",
         {:timeout => Chef::Config[:yum_timeout]}
       )
       # will still raise an exception, can't stub out the subsequent call
-      lambda { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.should raise_error(Chef::Exceptions::Exec)
+      expect { @provider.yum_command("yum -d0 -e0 -y install emacs-1.0") }.to raise_error(Chef::Exceptions::Exec)
     end
   end
 end
@@ -650,7 +650,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "9:1.7.3", [ 9, "1.7.3", nil ] ],
         [ "15:20020927", [ 15, "20020927", nil ] ]
       ].each do |x, y|
-        @rpmutils.version_parse(x).should == y
+        expect(@rpmutils.version_parse(x)).to eq(y)
       end
     end
 
@@ -660,7 +660,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "-1:1.7.3", [ nil, nil, "1:1.7.3" ] ],
         [ "-:20020927", [ nil, nil, ":20020927" ] ]
       ].each do |x, y|
-        @rpmutils.version_parse(x).should == y
+        expect(@rpmutils.version_parse(x)).to eq(y)
       end
     end
 
@@ -670,7 +670,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "1.7.3", [ nil, "1.7.3", nil ] ],
         [ "20020927", [ nil, "20020927", nil ] ]
       ].each do |x, y|
-        @rpmutils.version_parse(x).should == y
+        expect(@rpmutils.version_parse(x)).to eq(y)
       end
     end
 
@@ -680,7 +680,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "0001.7.3", [ nil, "0001.7.3", nil ] ],
         [ "20020927,3", [ nil, "20020927,3", nil ] ]
       ].each do |x, y|
-        @rpmutils.version_parse(x).should == y
+        expect(@rpmutils.version_parse(x)).to eq(y)
       end
     end
 
@@ -690,7 +690,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "1.7.3-1jpp.2.el5", [ nil, "1.7.3", "1jpp.2.el5" ] ],
         [ "20020927-46.el5", [ nil, "20020927", "46.el5" ] ]
       ].each do |x, y|
-        @rpmutils.version_parse(x).should == y
+        expect(@rpmutils.version_parse(x)).to eq(y)
       end
     end
 
@@ -700,7 +700,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "-1jpp.2.el5", [ nil, nil, "1jpp.2.el5" ] ],
         [ "-0020020927-46.el5", [ nil, "-0020020927", "46.el5" ] ]
       ].each do |x, y|
-        @rpmutils.version_parse(x).should == y
+        expect(@rpmutils.version_parse(x)).to eq(y)
       end
     end
   end
@@ -757,7 +757,7 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "0.0.1aa", "0.0.1aa", 0 ],
         [ "0.0.1a", "0.0.1aa", -1 ],
      ].each do |x, y, result|
-        @rpmutils.rpmvercmp(x,y).should == result
+        expect(@rpmutils.rpmvercmp(x,y)).to eq(result)
       end
     end
 
@@ -776,43 +776,43 @@ describe Chef::Provider::Package::Yum::RPMUtils do
         [ "", "", 0 ],
         [ "", "1.0.1", -1 ]
      ].each do |x, y, result|
-        @rpmutils.rpmvercmp(x,y).should == result
+        expect(@rpmutils.rpmvercmp(x,y)).to eq(result)
       end
     end
 
     it "tests isalnum good input" do
       [ 'a', 'z', 'A', 'Z', '0', '9' ].each do |t|
-        @rpmutils.isalnum(t).should == true
+        expect(@rpmutils.isalnum(t)).to eq(true)
       end
     end
 
     it "tests isalnum bad input" do
       [ '-', '.', '!', '^', ':', '_' ].each do |t|
-        @rpmutils.isalnum(t).should == false
+        expect(@rpmutils.isalnum(t)).to eq(false)
       end
     end
 
     it "tests isalpha good input" do
       [ 'a', 'z', 'A', 'Z', ].each do |t|
-        @rpmutils.isalpha(t).should == true
+        expect(@rpmutils.isalpha(t)).to eq(true)
       end
     end
 
     it "tests isalpha bad input" do
       [ '0', '9', '-', '.', '!', '^', ':', '_' ].each do |t|
-        @rpmutils.isalpha(t).should == false
+        expect(@rpmutils.isalpha(t)).to eq(false)
       end
     end
 
     it "tests isdigit good input" do
       [ '0', '9', ].each do |t|
-        @rpmutils.isdigit(t).should == true
+        expect(@rpmutils.isdigit(t)).to eq(true)
       end
     end
 
     it "tests isdigit bad input" do
       [ 'A', 'z', '-', '.', '!', '^', ':', '_' ].each do |t|
-        @rpmutils.isdigit(t).should == false
+        expect(@rpmutils.isdigit(t)).to eq(false)
       end
     end
   end
@@ -826,15 +826,15 @@ describe Chef::Provider::Package::Yum::RPMVersion do
     end
 
     it "should expose evr (name-version-release) available" do
-      @rpmv.e.should == 1
-      @rpmv.v.should == "1.6.5"
-      @rpmv.r.should == "9.36.el5"
+      expect(@rpmv.e).to eq(1)
+      expect(@rpmv.v).to eq("1.6.5")
+      expect(@rpmv.r).to eq("9.36.el5")
 
-      @rpmv.evr.should == "1:1.6.5-9.36.el5"
+      expect(@rpmv.evr).to eq("1:1.6.5-9.36.el5")
     end
 
     it "should output a version-release string" do
-      @rpmv.to_s.should == "1.6.5-9.36.el5"
+      expect(@rpmv.to_s).to eq("1.6.5-9.36.el5")
     end
   end
 
@@ -844,34 +844,34 @@ describe Chef::Provider::Package::Yum::RPMVersion do
     end
 
     it "should expose evr (name-version-release) available" do
-      @rpmv.e.should == 1
-      @rpmv.v.should == "1.6.5"
-      @rpmv.r.should == "9.36.el5"
+      expect(@rpmv.e).to eq(1)
+      expect(@rpmv.v).to eq("1.6.5")
+      expect(@rpmv.r).to eq("9.36.el5")
 
-      @rpmv.evr.should == "1:1.6.5-9.36.el5"
+      expect(@rpmv.evr).to eq("1:1.6.5-9.36.el5")
     end
 
     it "should output a version-release string" do
-      @rpmv.to_s.should == "1.6.5-9.36.el5"
+      expect(@rpmv.to_s).to eq("1.6.5-9.36.el5")
     end
   end
 
   it "should raise an error unless passed 1 or 3 args" do
-    lambda {
+    expect {
       Chef::Provider::Package::Yum::RPMVersion.new()
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMVersion.new("1:1.6.5-9.36.el5")
-    }.should_not raise_error
-    lambda {
+    }.not_to raise_error
+    expect {
       Chef::Provider::Package::Yum::RPMVersion.new("1:1.6.5-9.36.el5", "extra")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMVersion.new("1", "1.6.5", "9.36.el5")
-    }.should_not raise_error
-    lambda {
+    }.not_to raise_error
+    expect {
       Chef::Provider::Package::Yum::RPMVersion.new("1", "1.6.5", "9.36.el5", "extra")
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   # thanks version_class_spec.rb!
@@ -898,9 +898,9 @@ describe Chef::Provider::Package::Yum::RPMVersion do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
         lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
-        sm.should be < lg
-        lg.should be > sm
-        sm.should_not == lg
+        expect(sm).to be < lg
+        expect(lg).to be > sm
+        expect(sm).not_to eq(lg)
       end
     end
 
@@ -924,9 +924,9 @@ describe Chef::Provider::Package::Yum::RPMVersion do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
         lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
-        sm.should be < lg
-        lg.should be > sm
-        sm.should_not == lg
+        expect(sm).to be < lg
+        expect(lg).to be > sm
+        expect(sm).not_to eq(lg)
       end
     end
 
@@ -941,7 +941,7 @@ describe Chef::Provider::Package::Yum::RPMVersion do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
         lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
-        sm.should be == lg
+        expect(sm).to eq(lg)
       end
     end
 
@@ -956,7 +956,7 @@ describe Chef::Provider::Package::Yum::RPMVersion do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
         lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
-        sm.should be == lg
+        expect(sm).to eq(lg)
       end
     end
   end
@@ -980,9 +980,9 @@ describe Chef::Provider::Package::Yum::RPMVersion do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
         lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
-        sm.partial_compare(lg).should be == -1
-        lg.partial_compare(sm).should be == 1
-        sm.partial_compare(lg).should_not be == 0
+        expect(sm.partial_compare(lg)).to eq(-1)
+        expect(lg.partial_compare(sm)).to eq(1)
+        expect(sm.partial_compare(lg)).not_to eq(0)
       end
     end
 
@@ -997,7 +997,7 @@ describe Chef::Provider::Package::Yum::RPMVersion do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMVersion.new(smaller)
         lg = Chef::Provider::Package::Yum::RPMVersion.new(larger)
-        sm.partial_compare(lg).should be == 0
+        expect(sm.partial_compare(lg)).to eq(0)
       end
     end
   end
@@ -1011,18 +1011,18 @@ describe Chef::Provider::Package::Yum::RPMPackage do
     end
 
     it "should expose nevra (name-epoch-version-release-arch) available" do
-      @rpm.name.should == "testing"
-      @rpm.version.e.should == 1
-      @rpm.version.v.should == "1.6.5"
-      @rpm.version.r.should == "9.36.el5"
-      @rpm.arch.should == "x86_64"
+      expect(@rpm.name).to eq("testing")
+      expect(@rpm.version.e).to eq(1)
+      expect(@rpm.version.v).to eq("1.6.5")
+      expect(@rpm.version.r).to eq("9.36.el5")
+      expect(@rpm.arch).to eq("x86_64")
 
-      @rpm.nevra.should == "testing-1:1.6.5-9.36.el5.x86_64"
-      @rpm.to_s.should == @rpm.nevra
+      expect(@rpm.nevra).to eq("testing-1:1.6.5-9.36.el5.x86_64")
+      expect(@rpm.to_s).to eq(@rpm.nevra)
     end
 
     it "should always have at least one provide, itself" do
-      @rpm.provides.size.should == 1
+      expect(@rpm.provides.size).to eq(1)
       @rpm.provides[0].name == "testing"
       @rpm.provides[0].version.evr == "1:1.6.5-9.36.el5"
       @rpm.provides[0].flag == :==
@@ -1035,18 +1035,18 @@ describe Chef::Provider::Package::Yum::RPMPackage do
     end
 
     it "should expose nevra (name-epoch-version-release-arch) available" do
-      @rpm.name.should == "testing"
-      @rpm.version.e.should == 1
-      @rpm.version.v.should == "1.6.5"
-      @rpm.version.r.should == "9.36.el5"
-      @rpm.arch.should == "x86_64"
+      expect(@rpm.name).to eq("testing")
+      expect(@rpm.version.e).to eq(1)
+      expect(@rpm.version.v).to eq("1.6.5")
+      expect(@rpm.version.r).to eq("9.36.el5")
+      expect(@rpm.arch).to eq("x86_64")
 
-      @rpm.nevra.should == "testing-1:1.6.5-9.36.el5.x86_64"
-      @rpm.to_s.should == @rpm.nevra
+      expect(@rpm.nevra).to eq("testing-1:1.6.5-9.36.el5.x86_64")
+      expect(@rpm.to_s).to eq(@rpm.nevra)
     end
 
     it "should always have at least one provide, itself" do
-      @rpm.provides.size.should == 1
+      expect(@rpm.provides.size).to eq(1)
       @rpm.provides[0].name == "testing"
       @rpm.provides[0].version.evr == "1:1.6.5-9.36.el5"
       @rpm.provides[0].flag == :==
@@ -1054,30 +1054,30 @@ describe Chef::Provider::Package::Yum::RPMPackage do
   end
 
   it "should raise an error unless passed 4 or 6 args" do
-    lambda {
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new()
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5", "x86_64")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing", "1:1.6.5-9.36.el5", "x86_64", [])
-    }.should_not raise_error
-    lambda {
+    }.not_to raise_error
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64", [])
-    }.should_not raise_error
-    lambda {
+    }.not_to raise_error
+    expect {
       Chef::Provider::Package::Yum::RPMPackage.new("testing", "1", "1.6.5", "9.36.el5", "x86_64", [], "extra")
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   describe "<=>" do
@@ -1096,9 +1096,9 @@ describe Chef::Provider::Package::Yum::RPMPackage do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMPackage.new(smaller, "0:0.0.1-1", "x86_64", [])
         lg = Chef::Provider::Package::Yum::RPMPackage.new(larger, "0:0.0.1-1", "x86_64", [])
-        sm.should be < lg
-        lg.should be > sm
-        sm.should_not == lg
+        expect(sm).to be < lg
+        expect(lg).to be > sm
+        expect(sm).not_to eq(lg)
       end
     end
 
@@ -1113,9 +1113,9 @@ describe Chef::Provider::Package::Yum::RPMPackage do
       ].each do |smaller, larger|
         sm = Chef::Provider::Package::Yum::RPMPackage.new("test-package", "0:0.0.1-1", smaller, [])
         lg = Chef::Provider::Package::Yum::RPMPackage.new("test-package", "0:0.0.1-1", larger, [])
-        sm.should be < lg
-        lg.should be > sm
-        sm.should_not == lg
+        expect(sm).to be < lg
+        expect(lg).to be > sm
+        expect(sm).not_to eq(lg)
       end
     end
   end
@@ -1132,31 +1132,31 @@ describe Chef::Provider::Package::Yum::RPMDbPackage do
 
   describe "initialize" do
     it "should return a Chef::Provider::Package::Yum::RPMDbPackage object" do
-      @rpm_x.should be_kind_of(Chef::Provider::Package::Yum::RPMDbPackage)
+      expect(@rpm_x).to be_kind_of(Chef::Provider::Package::Yum::RPMDbPackage)
     end
   end
 
   describe "available" do
     it "should return true" do
-      @rpm_x.available.should be == true
-      @rpm_y.available.should be == true
-      @rpm_z.available.should be == false
+      expect(@rpm_x.available).to eq(true)
+      expect(@rpm_y.available).to eq(true)
+      expect(@rpm_z.available).to eq(false)
     end
   end
 
   describe "installed" do
     it "should return true" do
-      @rpm_x.installed.should be == false
-      @rpm_y.installed.should be == true
-      @rpm_z.installed.should be == true
+      expect(@rpm_x.installed).to eq(false)
+      expect(@rpm_y.installed).to eq(true)
+      expect(@rpm_z.installed).to eq(true)
     end
   end
 
   describe "repoid" do
     it "should return the source repository repoid" do
-      @rpm_x.repoid.should be == "base"
-      @rpm_y.repoid.should be == "extras"
-      @rpm_z.repoid.should be == "other"
+      expect(@rpm_x.repoid).to eq("base")
+      expect(@rpm_y.repoid).to eq("extras")
+      expect(@rpm_z.repoid).to eq("other")
     end
   end
 end
@@ -1168,11 +1168,11 @@ describe Chef::Provider::Package::Yum::RPMDependency do
     end
 
     it "should expose name, version, flag available" do
-      @rpmdep.name.should == "testing"
-      @rpmdep.version.e.should == 1
-      @rpmdep.version.v.should == "1.6.5"
-      @rpmdep.version.r.should == "9.36.el5"
-      @rpmdep.flag.should == :==
+      expect(@rpmdep.name).to eq("testing")
+      expect(@rpmdep.version.e).to eq(1)
+      expect(@rpmdep.version.v).to eq("1.6.5")
+      expect(@rpmdep.version.r).to eq("9.36.el5")
+      expect(@rpmdep.flag).to eq(:==)
     end
   end
 
@@ -1182,67 +1182,67 @@ describe Chef::Provider::Package::Yum::RPMDependency do
     end
 
     it "should expose name, version, flag available" do
-      @rpmdep.name.should == "testing"
-      @rpmdep.version.e.should == 1
-      @rpmdep.version.v.should == "1.6.5"
-      @rpmdep.version.r.should == "9.36.el5"
-      @rpmdep.flag.should == :==
+      expect(@rpmdep.name).to eq("testing")
+      expect(@rpmdep.version.e).to eq(1)
+      expect(@rpmdep.version.v).to eq("1.6.5")
+      expect(@rpmdep.version.r).to eq("9.36.el5")
+      expect(@rpmdep.flag).to eq(:==)
     end
   end
 
   it "should raise an error unless passed 3 or 5 args" do
-    lambda {
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new()
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new("testing")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
-    }.should_not raise_error
-    lambda {
+    }.not_to raise_error
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==, "extra")
-    }.should raise_error(ArgumentError)
-    lambda {
+    }.to raise_error(ArgumentError)
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new("testing", "1", "1.6.5", "9.36.el5", :==)
-    }.should_not raise_error
-    lambda {
+    }.not_to raise_error
+    expect {
       Chef::Provider::Package::Yum::RPMDependency.new("testing", "1", "1.6.5", "9.36.el5", :==, "extra")
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   describe "parse" do
     it "should parse a name, flag, version string into a valid RPMDependency object" do
       @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing >= 1:1.6.5-9.36.el5")
 
-      @rpmdep.name.should == "testing"
-      @rpmdep.version.e.should == 1
-      @rpmdep.version.v.should == "1.6.5"
-      @rpmdep.version.r.should == "9.36.el5"
-      @rpmdep.flag.should == :>=
+      expect(@rpmdep.name).to eq("testing")
+      expect(@rpmdep.version.e).to eq(1)
+      expect(@rpmdep.version.v).to eq("1.6.5")
+      expect(@rpmdep.version.r).to eq("9.36.el5")
+      expect(@rpmdep.flag).to eq(:>=)
     end
 
     it "should parse a name into a valid RPMDependency object" do
       @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing")
 
-      @rpmdep.name.should == "testing"
-      @rpmdep.version.e.should == nil
-      @rpmdep.version.v.should == nil
-      @rpmdep.version.r.should == nil
-      @rpmdep.flag.should == :==
+      expect(@rpmdep.name).to eq("testing")
+      expect(@rpmdep.version.e).to eq(nil)
+      expect(@rpmdep.version.v).to eq(nil)
+      expect(@rpmdep.version.r).to eq(nil)
+      expect(@rpmdep.flag).to eq(:==)
     end
 
     it "should parse an invalid string into the name of a RPMDependency object" do
       @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing blah >")
 
-      @rpmdep.name.should == "testing blah >"
-      @rpmdep.version.e.should == nil
-      @rpmdep.version.v.should == nil
-      @rpmdep.version.r.should == nil
-      @rpmdep.flag.should == :==
+      expect(@rpmdep.name).to eq("testing blah >")
+      expect(@rpmdep.version.e).to eq(nil)
+      expect(@rpmdep.version.v).to eq(nil)
+      expect(@rpmdep.version.r).to eq(nil)
+      expect(@rpmdep.flag).to eq(:==)
     end
 
     it "should parse various valid flags" do
@@ -1255,7 +1255,7 @@ describe Chef::Provider::Package::Yum::RPMDependency do
         [ "<", :< ]
       ].each do |before, after|
         @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing #{before} 1:1.1-1")
-        @rpmdep.flag.should == after
+        expect(@rpmdep.flag).to eq(after)
       end
     end
 
@@ -1269,8 +1269,8 @@ describe Chef::Provider::Package::Yum::RPMDependency do
         [ "~", :== ]
       ].each do |before, after|
         @rpmdep = Chef::Provider::Package::Yum::RPMDependency.parse("testing #{before} 1:1.1-1")
-        @rpmdep.name.should == "testing #{before} 1:1.1-1"
-        @rpmdep.flag.should == after
+        expect(@rpmdep.name).to eq("testing #{before} 1:1.1-1")
+        expect(@rpmdep.flag).to eq(after)
       end
     end
   end
@@ -1279,12 +1279,12 @@ describe Chef::Provider::Package::Yum::RPMDependency do
     it "should raise an error unless a RPMDependency is passed" do
       @rpmprovide = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
       @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :>=)
-      lambda {
+      expect {
         @rpmprovide.satisfy?("hi")
-      }.should raise_error(ArgumentError)
-      lambda {
+      }.to raise_error(ArgumentError)
+      expect {
         @rpmprovide.satisfy?(@rpmrequire)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should validate dependency satisfaction logic for standard examples" do
@@ -1326,8 +1326,8 @@ describe Chef::Provider::Package::Yum::RPMDependency do
         @rpmprovide = Chef::Provider::Package::Yum::RPMDependency.parse(prov)
         @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.parse(req)
 
-        @rpmprovide.satisfy?(@rpmrequire).should == result
-        @rpmrequire.satisfy?(@rpmprovide).should == result
+        expect(@rpmprovide.satisfy?(@rpmrequire)).to eq(result)
+        expect(@rpmrequire.satisfy?(@rpmprovide)).to eq(result)
       end
     end
   end
@@ -1358,89 +1358,89 @@ describe Chef::Provider::Package::Yum::RPMDb do
 
   describe "initialize" do
     it "should return a Chef::Provider::Package::Yum::RPMDb object" do
-      @rpmdb.should be_kind_of(Chef::Provider::Package::Yum::RPMDb)
+      expect(@rpmdb).to be_kind_of(Chef::Provider::Package::Yum::RPMDb)
     end
   end
 
   describe "push" do
     it "should accept an RPMDbPackage object through pushing" do
-      lambda { @rpmdb.push(@rpm_w) }.should_not raise_error
+      expect { @rpmdb.push(@rpm_w) }.not_to raise_error
     end
 
     it "should accept multiple RPMDbPackage object through pushing" do
-      lambda { @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z) }.should_not raise_error
+      expect { @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z) }.not_to raise_error
     end
 
     it "should only accept an RPMDbPackage object" do
-      lambda { @rpmdb.push("string") }.should raise_error
+      expect { @rpmdb.push("string") }.to raise_error
     end
 
     it "should add the package to the package db" do
       @rpmdb.push(@rpm_w)
-      @rpmdb["test-package-b"].should_not be == nil
+      expect(@rpmdb["test-package-b"]).not_to eq(nil)
     end
 
     it "should add conditionally add the package to the available list" do
-      @rpmdb.available_size.should be == 0
+      expect(@rpmdb.available_size).to eq(0)
       @rpmdb.push(@rpm_v, @rpm_w)
-      @rpmdb.available_size.should be == 1
+      expect(@rpmdb.available_size).to eq(1)
     end
 
     it "should add conditionally add the package to the installed list" do
-      @rpmdb.installed_size.should be == 0
+      expect(@rpmdb.installed_size).to eq(0)
       @rpmdb.push(@rpm_w, @rpm_x)
-      @rpmdb.installed_size.should be == 1
+      expect(@rpmdb.installed_size).to eq(1)
     end
 
     it "should have a total of 2 packages in the RPMDb" do
-      @rpmdb.size.should be == 0
+      expect(@rpmdb.size).to eq(0)
       @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
-      @rpmdb.size.should be == 2
+      expect(@rpmdb.size).to eq(2)
     end
 
     it "should keep the Array unique when a duplicate is pushed" do
       @rpmdb.push(@rpm_z, @rpm_z_mirror)
-      @rpmdb["test-package-c"].size.should be == 1
+      expect(@rpmdb["test-package-c"].size).to eq(1)
     end
 
     it "should register the package provides in the provides index" do
       @rpmdb.push(@rpm_v, @rpm_w, @rpm_z)
-      @rpmdb.lookup_provides("test-package-a")[0].should be == @rpm_v
-      @rpmdb.lookup_provides("config(test)")[0].should be == @rpm_z
-      @rpmdb.lookup_provides("libz.so.1()(64bit)")[0].should be == @rpm_v
-      @rpmdb.lookup_provides("libz.so.1()(64bit)")[1].should be == @rpm_z
+      expect(@rpmdb.lookup_provides("test-package-a")[0]).to eq(@rpm_v)
+      expect(@rpmdb.lookup_provides("config(test)")[0]).to eq(@rpm_z)
+      expect(@rpmdb.lookup_provides("libz.so.1()(64bit)")[0]).to eq(@rpm_v)
+      expect(@rpmdb.lookup_provides("libz.so.1()(64bit)")[1]).to eq(@rpm_z)
     end
   end
 
   describe "<<" do
     it "should accept an RPMPackage object through the << operator" do
-      lambda { @rpmdb << @rpm_w }.should_not raise_error
+      expect { @rpmdb << @rpm_w }.not_to raise_error
     end
   end
 
   describe "lookup" do
     it "should return an Array of RPMPackage objects by index" do
       @rpmdb << @rpm_w
-      @rpmdb.lookup("test-package-b").should be_kind_of(Array)
+      expect(@rpmdb.lookup("test-package-b")).to be_kind_of(Array)
     end
   end
 
   describe "[]" do
     it "should return an Array of RPMPackage objects though the [index] operator" do
       @rpmdb << @rpm_w
-      @rpmdb["test-package-b"].should be_kind_of(Array)
+      expect(@rpmdb["test-package-b"]).to be_kind_of(Array)
     end
 
     it "should return an Array of 3 RPMPackage objects" do
       @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
-      @rpmdb["test-package-b"].size.should be == 3
+      expect(@rpmdb["test-package-b"].size).to eq(3)
     end
 
     it "should return an Array of RPMPackage objects sorted from newest to oldest" do
       @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
-      @rpmdb["test-package-b"][0].should be == @rpm_y
-      @rpmdb["test-package-b"][1].should be == @rpm_x
-      @rpmdb["test-package-b"][2].should be == @rpm_w
+      expect(@rpmdb["test-package-b"][0]).to eq(@rpm_y)
+      expect(@rpmdb["test-package-b"][1]).to eq(@rpm_x)
+      expect(@rpmdb["test-package-b"][2]).to eq(@rpm_w)
     end
   end
 
@@ -1448,57 +1448,57 @@ describe Chef::Provider::Package::Yum::RPMDb do
     it "should return an Array of RPMPackage objects by index" do
       @rpmdb << @rpm_z
       x = @rpmdb.lookup_provides("config(test)")
-      x.should be_kind_of(Array)
-      x[0].should be == @rpm_z
+      expect(x).to be_kind_of(Array)
+      expect(x[0]).to eq(@rpm_z)
     end
   end
 
   describe "clear" do
     it "should clear the RPMDb" do
-      @rpmdb.should_receive(:clear_available).once
-      @rpmdb.should_receive(:clear_installed).once
+      expect(@rpmdb).to receive(:clear_available).once
+      expect(@rpmdb).to receive(:clear_installed).once
       @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
-      @rpmdb.size.should_not be == 0
-      @rpmdb.lookup_provides("config(test)").should be_kind_of(Array)
+      expect(@rpmdb.size).not_to eq(0)
+      expect(@rpmdb.lookup_provides("config(test)")).to be_kind_of(Array)
       @rpmdb.clear
-      @rpmdb.lookup_provides("config(test)").should be == nil
-      @rpmdb.size.should be == 0
+      expect(@rpmdb.lookup_provides("config(test)")).to eq(nil)
+      expect(@rpmdb.size).to eq(0)
     end
   end
 
   describe "clear_available" do
     it "should clear the available list" do
       @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
-      @rpmdb.available_size.should_not be == 0
+      expect(@rpmdb.available_size).not_to eq(0)
       @rpmdb.clear_available
-      @rpmdb.available_size.should be == 0
+      expect(@rpmdb.available_size).to eq(0)
     end
   end
 
   describe "available?" do
     it "should return true if a package is available" do
-      @rpmdb.available?(@rpm_w).should be == false
+      expect(@rpmdb.available?(@rpm_w)).to eq(false)
       @rpmdb.push(@rpm_v, @rpm_w)
-      @rpmdb.available?(@rpm_v).should be == false
-      @rpmdb.available?(@rpm_w).should be == true
+      expect(@rpmdb.available?(@rpm_v)).to eq(false)
+      expect(@rpmdb.available?(@rpm_w)).to eq(true)
     end
   end
 
   describe "clear_installed" do
     it "should clear the installed list" do
       @rpmdb.push(@rpm_w, @rpm_x, @rpm_y, @rpm_z)
-      @rpmdb.installed_size.should_not be == 0
+      expect(@rpmdb.installed_size).not_to eq(0)
       @rpmdb.clear_installed
-      @rpmdb.installed_size.should be == 0
+      expect(@rpmdb.installed_size).to eq(0)
     end
   end
 
   describe "installed?" do
     it "should return true if a package is installed" do
-      @rpmdb.installed?(@rpm_w).should be == false
+      expect(@rpmdb.installed?(@rpm_w)).to eq(false)
       @rpmdb.push(@rpm_w, @rpm_x)
-      @rpmdb.installed?(@rpm_w).should be == true
-      @rpmdb.installed?(@rpm_x).should be == false
+      expect(@rpmdb.installed?(@rpm_w)).to eq(true)
+      expect(@rpmdb.installed?(@rpm_x)).to eq(false)
     end
   end
 
@@ -1506,12 +1506,12 @@ describe Chef::Provider::Package::Yum::RPMDb do
     it "should raise an error unless a RPMDependency is passed" do
       @rpmprovide = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :==)
       @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.new("testing", "1:1.6.5-9.36.el5", :>=)
-      lambda {
+      expect {
         @rpmdb.whatprovides("hi")
-      }.should raise_error(ArgumentError)
-      lambda {
+      }.to raise_error(ArgumentError)
+      expect {
         @rpmdb.whatprovides(@rpmrequire)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should return an Array of packages statisfying a RPMDependency" do
@@ -1519,14 +1519,14 @@ describe Chef::Provider::Package::Yum::RPMDb do
 
       @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.parse("test-package-a >= 1.6.5")
       x = @rpmdb.whatprovides(@rpmrequire)
-      x.should be_kind_of(Array)
-      x[0].should be == @rpm_v
+      expect(x).to be_kind_of(Array)
+      expect(x[0]).to eq(@rpm_v)
 
       @rpmrequire = Chef::Provider::Package::Yum::RPMDependency.parse("libz.so.1()(64bit)")
       x = @rpmdb.whatprovides(@rpmrequire)
-      x.should be_kind_of(Array)
-      x[0].should be == @rpm_v
-      x[1].should be == @rpm_z
+      expect(x).to be_kind_of(Array)
+      expect(x[0]).to eq(@rpm_v)
+      expect(x[1]).to eq(@rpm_z)
     end
   end
 
@@ -1592,18 +1592,18 @@ EOF
     Chef::Provider::Package::Yum::YumCache.reset_instance
     @yc = Chef::Provider::Package::Yum::YumCache.instance
     # load valid data
-    @yc.stub(:shell_out!).and_return(@status)
+    allow(@yc).to receive(:shell_out!).and_return(@status)
   end
 
   describe "initialize" do
     it "should return a Chef::Provider::Package::Yum::YumCache object" do
-      @yc.should be_kind_of(Chef::Provider::Package::Yum::YumCache)
+      expect(@yc).to be_kind_of(Chef::Provider::Package::Yum::YumCache)
     end
 
     it "should register reload for start of Chef::Client runs" do
       Chef::Provider::Package::Yum::YumCache.reset_instance
-      Chef::Client.should_receive(:when_run_starts) do |&b|
-        b.should_not be_nil
+      expect(Chef::Client).to receive(:when_run_starts) do |&b|
+        expect(b).not_to be_nil
       end
       @yc = Chef::Provider::Package::Yum::YumCache.instance
     end
@@ -1611,7 +1611,7 @@ EOF
 
   describe "refresh" do
     it "should implicitly call yum-dump.py only once by default after being instantiated" do
-      @yc.should_receive(:shell_out!).once
+      expect(@yc).to receive(:shell_out!).once
       @yc.installed_version("zlib")
       @yc.reset
       @yc.installed_version("zlib")
@@ -1619,226 +1619,226 @@ EOF
 
     it "should run yum-dump.py using the system python when next_refresh is for :all" do
       @yc.reload
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
+      expect(@yc).to receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should run yum-dump.py with the installed flag when next_refresh is for :installed" do
       @yc.reload_installed
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --installed --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
+      expect(@yc).to receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --installed --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should run yum-dump.py with the all-provides flag when next_refresh is for :provides" do
       @yc.reload_provides
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --all-provides --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
+      expect(@yc).to receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --all-provides --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should pass extra_repo_control args to yum-dump.py" do
       @yc.enable_extra_repo_control("--enablerepo=foo --disablerepo=bar")
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
+      expect(@yc).to receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should pass extra_repo_control args and configured yum lock timeout to yum-dump.py" do
       Chef::Config[:yum_lock_timeout] = 999
       @yc.enable_extra_repo_control("--enablerepo=foo --disablerepo=bar")
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar --yum-lock-timeout 999$}, :timeout=>Chef::Config[:yum_timeout])
+      expect(@yc).to receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar --yum-lock-timeout 999$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should warn about invalid data with too many separators" do
       @status = double("Status", :exitstatus => 0, :stdin => @stdin, :stdout => @stdout_bad_separators, :stderr => @stderr)
-      @yc.stub(:shell_out!).and_return(@status)
-      Chef::Log.should_receive(:warn).exactly(3).times.with(%r{Problem parsing})
+      allow(@yc).to receive(:shell_out!).and_return(@status)
+      expect(Chef::Log).to receive(:warn).exactly(3).times.with(%r{Problem parsing})
       @yc.refresh
     end
 
     it "should warn about invalid data with an incorrect type" do
       @status = double("Status", :exitstatus => 0, :stdin => @stdin, :stdout => @stdout_bad_type, :stderr => @stderr)
-      @yc.stub(:shell_out!).and_return(@status)
-      Chef::Log.should_receive(:warn).exactly(2).times.with(%r{Problem parsing})
+      allow(@yc).to receive(:shell_out!).and_return(@status)
+      expect(Chef::Log).to receive(:warn).exactly(2).times.with(%r{Problem parsing})
       @yc.refresh
     end
 
     it "should warn about no output from yum-dump.py" do
       @status = double("Status", :exitstatus => 0, :stdin => @stdin, :stdout => @stdout_no_output, :stderr => @stderr)
-      @yc.stub(:shell_out!).and_return(@status)
-      Chef::Log.should_receive(:warn).exactly(1).times.with(%r{no output from yum-dump.py})
+      allow(@yc).to receive(:shell_out!).and_return(@status)
+      expect(Chef::Log).to receive(:warn).exactly(1).times.with(%r{no output from yum-dump.py})
       @yc.refresh
     end
 
     it "should raise exception yum-dump.py exits with a non zero status" do
       @status = double("Status", :exitstatus => 1, :stdin => @stdin, :stdout => @stdout_no_output, :stderr => @stderr)
-      @yc.stub(:shell_out!).and_return(@status)
-      lambda { @yc.refresh}.should raise_error(Chef::Exceptions::Package, %r{CentOS-Base.repo, line: 12})
+      allow(@yc).to receive(:shell_out!).and_return(@status)
+      expect { @yc.refresh}.to raise_error(Chef::Exceptions::Package, %r{CentOS-Base.repo, line: 12})
     end
 
     it "should parse type 'i' into an installed state for a package" do
-      @yc.available_version("erlang-mochiweb").should be == nil
-      @yc.installed_version("erlang-mochiweb").should_not be == nil
+      expect(@yc.available_version("erlang-mochiweb")).to eq(nil)
+      expect(@yc.installed_version("erlang-mochiweb")).not_to eq(nil)
     end
 
     it "should parse type 'a' into an available state for a package" do
-      @yc.available_version("znc").should_not be == nil
-      @yc.installed_version("znc").should be == nil
+      expect(@yc.available_version("znc")).not_to eq(nil)
+      expect(@yc.installed_version("znc")).to eq(nil)
     end
 
     it "should parse type 'r' into an installed and available states for a package" do
-      @yc.available_version("zip").should_not be == nil
-      @yc.installed_version("zip").should_not be == nil
+      expect(@yc.available_version("zip")).not_to eq(nil)
+      expect(@yc.installed_version("zip")).not_to eq(nil)
     end
 
     it "should parse installonlypkgs from yum-dump.py options output" do
-      @yc.allow_multi_install.should be == %w{kernel kernel-bigmem kernel-enterprise}
+      expect(@yc.allow_multi_install).to eq(%w{kernel kernel-bigmem kernel-enterprise})
     end
   end
 
   describe "installed_version" do
     it "should take one or two arguments" do
-      lambda { @yc.installed_version("zip") }.should_not raise_error
-      lambda { @yc.installed_version("zip", "i386") }.should_not raise_error
-      lambda { @yc.installed_version("zip", "i386", "extra") }.should raise_error(ArgumentError)
+      expect { @yc.installed_version("zip") }.not_to raise_error
+      expect { @yc.installed_version("zip", "i386") }.not_to raise_error
+      expect { @yc.installed_version("zip", "i386", "extra") }.to raise_error(ArgumentError)
     end
 
     it "should return version-release for matching package regardless of arch" do
-      @yc.installed_version("zip", "x86_64").should be == "2.31-2.el5"
-      @yc.installed_version("zip", nil).should be == "2.31-2.el5"
+      expect(@yc.installed_version("zip", "x86_64")).to eq("2.31-2.el5")
+      expect(@yc.installed_version("zip", nil)).to eq("2.31-2.el5")
     end
 
     it "should return version-release for matching package and arch" do
-      @yc.installed_version("zip", "x86_64").should be == "2.31-2.el5"
-      @yc.installed_version("zisofs-tools", "i386").should be == nil
+      expect(@yc.installed_version("zip", "x86_64")).to eq("2.31-2.el5")
+      expect(@yc.installed_version("zisofs-tools", "i386")).to eq(nil)
     end
 
     it "should return nil for an unmatched package" do
-      @yc.installed_version(nil, nil).should be == nil
-      @yc.installed_version("test1", nil).should be == nil
-      @yc.installed_version("test2", "x86_64").should be == nil
+      expect(@yc.installed_version(nil, nil)).to eq(nil)
+      expect(@yc.installed_version("test1", nil)).to eq(nil)
+      expect(@yc.installed_version("test2", "x86_64")).to eq(nil)
     end
   end
 
   describe "available_version" do
     it "should take one or two arguments" do
-      lambda { @yc.available_version("zisofs-tools") }.should_not raise_error
-      lambda { @yc.available_version("zisofs-tools", "i386") }.should_not raise_error
-      lambda { @yc.available_version("zisofs-tools", "i386", "extra") }.should raise_error(ArgumentError)
+      expect { @yc.available_version("zisofs-tools") }.not_to raise_error
+      expect { @yc.available_version("zisofs-tools", "i386") }.not_to raise_error
+      expect { @yc.available_version("zisofs-tools", "i386", "extra") }.to raise_error(ArgumentError)
     end
 
     it "should return version-release for matching package regardless of arch" do
-      @yc.available_version("zip", "x86_64").should be == "2.31-2.el5"
-      @yc.available_version("zip", nil).should be == "2.31-2.el5"
+      expect(@yc.available_version("zip", "x86_64")).to eq("2.31-2.el5")
+      expect(@yc.available_version("zip", nil)).to eq("2.31-2.el5")
     end
 
     it "should return version-release for matching package and arch" do
-      @yc.available_version("zip", "x86_64").should be == "2.31-2.el5"
-      @yc.available_version("zisofs-tools", "i386").should be == nil
+      expect(@yc.available_version("zip", "x86_64")).to eq("2.31-2.el5")
+      expect(@yc.available_version("zisofs-tools", "i386")).to eq(nil)
     end
 
     it "should return nil for an unmatched package" do
-      @yc.available_version(nil, nil).should be == nil
-      @yc.available_version("test1", nil).should be == nil
-      @yc.available_version("test2", "x86_64").should be == nil
+      expect(@yc.available_version(nil, nil)).to eq(nil)
+      expect(@yc.available_version("test1", nil)).to eq(nil)
+      expect(@yc.available_version("test2", "x86_64")).to eq(nil)
     end
   end
 
   describe "version_available?" do
     it "should take two or three arguments" do
-      lambda { @yc.version_available?("zisofs-tools") }.should raise_error(ArgumentError)
-      lambda { @yc.version_available?("zisofs-tools", "1.0.6-3.2.2") }.should_not raise_error
-      lambda { @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "x86_64") }.should_not raise_error
+      expect { @yc.version_available?("zisofs-tools") }.to raise_error(ArgumentError)
+      expect { @yc.version_available?("zisofs-tools", "1.0.6-3.2.2") }.not_to raise_error
+      expect { @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "x86_64") }.not_to raise_error
     end
 
     it "should return true if our package-version-arch is available" do
-      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "x86_64").should be == true
+      expect(@yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "x86_64")).to eq(true)
     end
 
     it "should return true if our package-version, no arch, is available" do
-      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", nil).should be == true
-      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2").should be == true
+      expect(@yc.version_available?("zisofs-tools", "1.0.6-3.2.2", nil)).to eq(true)
+      expect(@yc.version_available?("zisofs-tools", "1.0.6-3.2.2")).to eq(true)
     end
 
     it "should return false if our package-version-arch isn't available" do
-      @yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "pretend").should be == false
-      @yc.version_available?("zisofs-tools", "pretend", "x86_64").should be == false
-      @yc.version_available?("pretend", "1.0.6-3.2.2", "x86_64").should be == false
+      expect(@yc.version_available?("zisofs-tools", "1.0.6-3.2.2", "pretend")).to eq(false)
+      expect(@yc.version_available?("zisofs-tools", "pretend", "x86_64")).to eq(false)
+      expect(@yc.version_available?("pretend", "1.0.6-3.2.2", "x86_64")).to eq(false)
     end
 
     it "should return false if our package-version, no arch, isn't available" do
-      @yc.version_available?("zisofs-tools", "pretend", nil).should be == false
-      @yc.version_available?("zisofs-tools", "pretend").should be == false
-      @yc.version_available?("pretend", "1.0.6-3.2.2").should be == false
+      expect(@yc.version_available?("zisofs-tools", "pretend", nil)).to eq(false)
+      expect(@yc.version_available?("zisofs-tools", "pretend")).to eq(false)
+      expect(@yc.version_available?("pretend", "1.0.6-3.2.2")).to eq(false)
     end
   end
 
   describe "package_repository" do
     it "should take two or three arguments" do
-      lambda { @yc.package_repository("zisofs-tools") }.should raise_error(ArgumentError)
-      lambda { @yc.package_repository("zisofs-tools", "1.0.6-3.2.2") }.should_not raise_error
-      lambda { @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", "x86_64") }.should_not raise_error
+      expect { @yc.package_repository("zisofs-tools") }.to raise_error(ArgumentError)
+      expect { @yc.package_repository("zisofs-tools", "1.0.6-3.2.2") }.not_to raise_error
+      expect { @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", "x86_64") }.not_to raise_error
     end
 
     it "should return repoid for package-version-arch" do
-      @yc.package_repository("zlib-devel", "1.2.3-3", "i386").should be == "extras"
-      @yc.package_repository("zlib-devel", "1.2.3-3", "x86_64").should be == "base"
+      expect(@yc.package_repository("zlib-devel", "1.2.3-3", "i386")).to eq("extras")
+      expect(@yc.package_repository("zlib-devel", "1.2.3-3", "x86_64")).to eq("base")
     end
 
     it "should return repoid for package-version, no arch" do
-      @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", nil).should be == "extras"
-      @yc.package_repository("zisofs-tools", "1.0.6-3.2.2").should be == "extras"
+      expect(@yc.package_repository("zisofs-tools", "1.0.6-3.2.2", nil)).to eq("extras")
+      expect(@yc.package_repository("zisofs-tools", "1.0.6-3.2.2")).to eq("extras")
     end
 
     it "should return nil when no match for package-version-arch" do
-      @yc.package_repository("zisofs-tools", "1.0.6-3.2.2", "pretend").should be == nil
-      @yc.package_repository("zisofs-tools", "pretend", "x86_64").should be == nil
-      @yc.package_repository("pretend", "1.0.6-3.2.2", "x86_64").should be == nil
+      expect(@yc.package_repository("zisofs-tools", "1.0.6-3.2.2", "pretend")).to eq(nil)
+      expect(@yc.package_repository("zisofs-tools", "pretend", "x86_64")).to eq(nil)
+      expect(@yc.package_repository("pretend", "1.0.6-3.2.2", "x86_64")).to eq(nil)
     end
 
     it "should return nil when no match for package-version, no arch" do
-      @yc.package_repository("zisofs-tools", "pretend", nil).should be == nil
-      @yc.package_repository("zisofs-tools", "pretend").should be == nil
-      @yc.package_repository("pretend", "1.0.6-3.2.2").should be == nil
+      expect(@yc.package_repository("zisofs-tools", "pretend", nil)).to eq(nil)
+      expect(@yc.package_repository("zisofs-tools", "pretend")).to eq(nil)
+      expect(@yc.package_repository("pretend", "1.0.6-3.2.2")).to eq(nil)
     end
   end
 
   describe "reset" do
     it "should empty the installed and available packages RPMDb" do
-      @yc.available_version("zip", "x86_64").should be == "2.31-2.el5"
-      @yc.installed_version("zip", "x86_64").should be == "2.31-2.el5"
+      expect(@yc.available_version("zip", "x86_64")).to eq("2.31-2.el5")
+      expect(@yc.installed_version("zip", "x86_64")).to eq("2.31-2.el5")
       @yc.reset
-      @yc.available_version("zip", "x86_64").should be == nil
-      @yc.installed_version("zip", "x86_64").should be == nil
+      expect(@yc.available_version("zip", "x86_64")).to eq(nil)
+      expect(@yc.installed_version("zip", "x86_64")).to eq(nil)
     end
   end
 
   describe "package_available?" do
     it "should return true a package name is available" do
-      @yc.package_available?("zisofs-tools").should be == true
-      @yc.package_available?("moo").should be == false
-      @yc.package_available?(nil).should be == false
+      expect(@yc.package_available?("zisofs-tools")).to eq(true)
+      expect(@yc.package_available?("moo")).to eq(false)
+      expect(@yc.package_available?(nil)).to eq(false)
     end
 
     it "should return true a package name + arch is available" do
-      @yc.package_available?("zlib-devel.i386").should be == true
-      @yc.package_available?("zisofs-tools.x86_64").should be == true
-      @yc.package_available?("znc-test.beta1.x86_64").should be == true
-      @yc.package_available?("znc-test.beta1").should be == true
-      @yc.package_available?("znc-test.test.beta1").should be == true
-      @yc.package_available?("moo.i386").should be == false
-      @yc.package_available?("zisofs-tools.beta").should be == false
-      @yc.package_available?("znc-test.test").should be == false
+      expect(@yc.package_available?("zlib-devel.i386")).to eq(true)
+      expect(@yc.package_available?("zisofs-tools.x86_64")).to eq(true)
+      expect(@yc.package_available?("znc-test.beta1.x86_64")).to eq(true)
+      expect(@yc.package_available?("znc-test.beta1")).to eq(true)
+      expect(@yc.package_available?("znc-test.test.beta1")).to eq(true)
+      expect(@yc.package_available?("moo.i386")).to eq(false)
+      expect(@yc.package_available?("zisofs-tools.beta")).to eq(false)
+      expect(@yc.package_available?("znc-test.test")).to eq(false)
     end
   end
 
   describe "enable_extra_repo_control" do
     it "should set @extra_repo_control to arg" do
       @yc.enable_extra_repo_control("--enablerepo=test")
-      @yc.extra_repo_control.should be == "--enablerepo=test"
+      expect(@yc.extra_repo_control).to eq("--enablerepo=test")
     end
 
     it "should call reload once when set to flag cache for update" do
-      @yc.should_receive(:reload).once
+      expect(@yc).to receive(:reload).once
       @yc.enable_extra_repo_control("--enablerepo=test")
       @yc.enable_extra_repo_control("--enablerepo=test")
     end
@@ -1848,13 +1848,13 @@ EOF
     it "should set @extra_repo_control to nil" do
       @yc.enable_extra_repo_control("--enablerepo=test")
       @yc.disable_extra_repo_control
-      @yc.extra_repo_control.should be == nil
+      expect(@yc.extra_repo_control).to eq(nil)
     end
 
     it "should call reload once when cleared to flag cache for update" do
-      @yc.should_receive(:reload).once
+      expect(@yc).to receive(:reload).once
       @yc.enable_extra_repo_control("--enablerepo=test")
-      @yc.should_receive(:reload).once
+      expect(@yc).to receive(:reload).once
       @yc.disable_extra_repo_control
       @yc.disable_extra_repo_control
     end