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

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

@@ -28,7 +28,7 @@ describe Chef::Provider::Package::Paludis do
     @run_context = Chef::RunContext.new(@node, {}, @events)
     @new_resource = Chef::Resource::Package.new("net/ntp")
     @current_resource = Chef::Resource::Package.new("net/ntp")
-    Chef::Resource::Package.stub(:new).and_return(@current_resource)
+    allow(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
     @provider = Chef::Provider::Package::Paludis.new(@new_resource, @run_context)
 
     @stdin = StringIO.new
@@ -47,19 +47,19 @@ PKG_STATUS
 
   context "when loading current resource" do
     it "should create a current resource with the name of the new_resource" do
-      @provider.should_receive(:shell_out!).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 resources package name to the new resources 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 run pkg info with the package name" do
-      @provider.should_receive(:shell_out!).with("cave -L warning print-ids -M none -m \"*/#{@new_resource.package_name.split('/').last}\" -f \"%c/%p %v %r\n\"").and_return(@shell_out)
+      expect(@provider).to receive(:shell_out!).with("cave -L warning print-ids -M none -m \"#{@new_resource.package_name}\" -f \"%c/%p %v %r\n\"").and_return(@shell_out)
       @provider.load_current_resource
     end
 
@@ -72,28 +72,28 @@ user/ntp 0 accounts
 user/ntp 0 installed-accounts
 net/ntp 4.2.6_p5-r1 installed
 INSTALLED
-      @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 == "4.2.6_p5-r1"
-      @provider.candidate_version.should eql("4.2.6_p5-r2")
+      expect(@current_resource.version).to eq("4.2.6_p5-r1")
+      expect(@provider.candidate_version).to eql("4.2.6_p5-r2")
     end
 
     it "should return the current resource" do
-      @provider.should_receive(:shell_out!).and_return(@shell_out)
-      @provider.load_current_resource.should eql(@current_resource)
+      expect(@provider).to receive(:shell_out!).and_return(@shell_out)
+      expect(@provider.load_current_resource).to eql(@current_resource)
     end
   end
 
   context "when installing a package" do
     it "should run pkg install with the package name and version" do
-      @provider.should_receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
       @provider.install_package("net/ntp", "4.2.6_p5-r2")
     end
 
 
     it "should run pkg install with the package name and version and options if specified" do
-      @provider.should_receive(:shell_out!).with("cave -L warning resolve -x --preserve-world \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
-      @new_resource.stub(:options).and_return("--preserve-world")
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x --preserve-world \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
+      allow(@new_resource).to receive(:options).and_return("--preserve-world")
       @provider.install_package("net/ntp", "4.2.6_p5-r2")
     end
 
@@ -102,7 +102,7 @@ INSTALLED
 sys-process/lsof 4.87 arbor
 sys-process/lsof 4.87 x86_64
 PKG_STATUS
-      @provider.should_receive(:shell_out!).with("cave -L warning resolve -x \"=sys-process/lsof-4.87\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=sys-process/lsof-4.87\"", {:timeout=>@new_resource.timeout})
       @provider.install_package("sys-process/lsof", "4.87")
     end
 
@@ -111,23 +111,23 @@ PKG_STATUS
 sys-process/lsof 4.87 arbor
 sys-process/lsof 4.87 x86_64
 PKG_STATUS
-      @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 be_nil
-      @provider.candidate_version.should eql("4.87")
+      expect(@current_resource.version).to be_nil
+      expect(@provider.candidate_version).to eql("4.87")
     end
   end
 
   context "when upgrading a package" do
     it "should run pkg install with the package name and version" do
-      @provider.should_receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
+      expect(@provider).to receive(:shell_out!).with("cave -L warning resolve -x \"=net/ntp-4.2.6_p5-r2\"", {:timeout=>@new_resource.timeout})
       @provider.upgrade_package("net/ntp", "4.2.6_p5-r2")
     end
   end
 
   context "when uninstalling a package" do
     it "should run pkg uninstall with the package name and version" do
-      @provider.should_receive(:shell_out!).with("cave -L warning uninstall -x \"=net/ntp-4.2.6_p5-r2\"")
+      expect(@provider).to receive(:shell_out!).with("cave -L warning uninstall -x \"=net/ntp-4.2.6_p5-r2\"")
       @provider.remove_package("net/ntp", "4.2.6_p5-r2")
     end
 

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

@@ -27,73 +27,73 @@ describe Chef::Provider::Package::Portage, "load_current_resource" do
     @current_resource = Chef::Resource::Package.new("dev-util/git")
 
     @provider = Chef::Provider::Package::Portage.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)
   end
 
   describe "when determining the current state of the package" do
 
     it "should create a current resource with the name of new_resource" do
-      ::Dir.stub(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0"])
-      Chef::Resource::Package.should_receive(:new).and_return(@current_resource)
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0"])
+      expect(Chef::Resource::Package).to receive(:new).and_return(@current_resource)
       @provider.load_current_resource
     end
 
     it "should set the current resource package name to the new resource package name" do
-      ::Dir.stub(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0"])
-      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0"])
+      expect(@current_resource).to receive(:package_name).with(@new_resource.package_name)
       @provider.load_current_resource
     end
 
     it "should return a current resource with the correct version if the package is found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-foobar-0.9", "/var/db/pkg/dev-util/git-1.0.0"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-foobar-0.9", "/var/db/pkg/dev-util/git-1.0.0"])
       @provider.load_current_resource
-      @provider.current_resource.version.should == "1.0.0"
+      expect(@provider.current_resource.version).to eq("1.0.0")
     end
 
     it "should return a current resource with the correct version if the package is found with revision" do
-      ::Dir.stub(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0-r1"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0-r1"])
       @provider.load_current_resource
-      @provider.current_resource.version.should == "1.0.0-r1"
+      expect(@provider.current_resource.version).to eq("1.0.0-r1")
     end
 
     it "should return a current resource with a nil version if the package is not found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
 
     it "should return a package name match from /var/db/pkg/* if a category isn't specified and a match is found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-foobar-0.9", "/var/db/pkg/dev-util/git-1.0.0"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-foobar-0.9", "/var/db/pkg/dev-util/git-1.0.0"])
       @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
       @provider.load_current_resource
-      @provider.current_resource.version.should == "1.0.0"
+      expect(@provider.current_resource.version).to eq("1.0.0")
     end
 
     it "should return a current resource with a nil version if a category isn't specified and a name match from /var/db/pkg/* is not found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/notgit-1.0.0"])
       @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
 
     it "should throw an exception if a category isn't specified and multiple packages are found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/funny-words/git-1.0.0"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/funny-words/git-1.0.0"])
       @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
-      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should return a current resource with a nil version if a category is specified and multiple packages are found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/funny-words/git-1.0.0"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/dev-util/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/funny-words/git-1.0.0"])
       @provider = Chef::Provider::Package::Portage.new(@new_resource, @run_context)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
 
     it "should return a current resource with a nil version if a category is not specified and multiple packages from the same category are found" do
-      ::Dir.stub(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/dev-util/git-1.0.1"])
+      allow(::Dir).to receive(:[]).with("/var/db/pkg/*/git-*").and_return(["/var/db/pkg/dev-util/git-1.0.0", "/var/db/pkg/dev-util/git-1.0.1"])
       @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
   end
 
@@ -102,14 +102,14 @@ describe Chef::Provider::Package::Portage, "load_current_resource" do
     describe Chef::Provider::Package::Portage, "candidate_version" do
       it "should return the candidate_version variable if already set" do
         @provider.candidate_version = "1.0.0"
-        @provider.should_not_receive(:popen4)
+        expect(@provider).not_to receive(:popen4)
         @provider.candidate_version
       end
 
       it "should throw an 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
 
       it "should find the candidate_version if a category is specifed and there are no duplicates" do
@@ -144,8 +144,8 @@ Searching...
 EOF
 
         @status = double("Status", :exitstatus => 0)
-        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
-        @provider.candidate_version.should == "1.6.0.6"
+        expect(@provider).to receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        expect(@provider.candidate_version).to eq("1.6.0.6")
       end
 
       it "should find the candidate_version if a category is not specifed and there are no duplicates" do
@@ -181,8 +181,8 @@ EOF
 
         @status = double("Status", :exitstatus => 0)
         @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
-        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
-        @provider.candidate_version.should == "1.6.0.6"
+        expect(@provider).to receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        expect(@provider.candidate_version).to eq("1.6.0.6")
       end
 
       it "should throw an exception if a category is not specified and there are duplicates" do
@@ -226,8 +226,8 @@ EOF
 
         @status = double("Status", :exitstatus => 0)
         @provider = Chef::Provider::Package::Portage.new(@new_resource_without_category, @run_context)
-        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
-        lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+        expect(@provider).to receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        expect { @provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
       end
 
       it "should find the candidate_version if a category is specifed and there are category duplicates" do
@@ -271,25 +271,25 @@ EOF
 
         @status = double("Status", :exitstatus => 0)
         @provider = Chef::Provider::Package::Portage.new(@new_resource, @run_context)
-        @provider.should_receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
-        @provider.candidate_version.should == "1.6.0.6"
+        expect(@provider).to receive(:popen4).and_yield(nil, nil, StringIO.new(output), nil).and_return(@status)
+        expect(@provider.candidate_version).to eq("1.6.0.6")
       end
     end
 
     describe Chef::Provider::Package::Portage, "install_package" do
       it "should install a normally versioned package using portage" do
-        @provider.should_receive(:shell_out!).with("emerge -g --color n --nospinner --quiet =dev-util/git-1.0.0")
+        expect(@provider).to receive(:shell_out!).with("emerge -g --color n --nospinner --quiet =dev-util/git-1.0.0")
         @provider.install_package("dev-util/git", "1.0.0")
       end
 
       it "should install a tilde versioned package using portage" do
-        @provider.should_receive(:shell_out!).with("emerge -g --color n --nospinner --quiet ~dev-util/git-1.0.0")
+        expect(@provider).to receive(:shell_out!).with("emerge -g --color n --nospinner --quiet ~dev-util/git-1.0.0")
         @provider.install_package("dev-util/git", "~1.0.0")
       end
 
       it "should add options to the emerge command when specified" do
-        @provider.should_receive(:shell_out!).with("emerge -g --color n --nospinner --quiet --oneshot =dev-util/git-1.0.0")
-        @new_resource.stub(:options).and_return("--oneshot")
+        expect(@provider).to receive(:shell_out!).with("emerge -g --color n --nospinner --quiet --oneshot =dev-util/git-1.0.0")
+        allow(@new_resource).to receive(:options).and_return("--oneshot")
 
         @provider.install_package("dev-util/git", "1.0.0")
       end
@@ -297,12 +297,12 @@ EOF
 
     describe Chef::Provider::Package::Portage, "remove_package" do
       it "should un-emerge the package with no version specified" do
-        @provider.should_receive(:shell_out!).with("emerge --unmerge --color n --nospinner --quiet dev-util/git")
+        expect(@provider).to receive(:shell_out!).with("emerge --unmerge --color n --nospinner --quiet dev-util/git")
         @provider.remove_package("dev-util/git", nil)
       end
 
       it "should un-emerge the package with a version specified" do
-        @provider.should_receive(:shell_out!).with("emerge --unmerge --color n --nospinner --quiet =dev-util/git-1.0.0")
+        expect(@provider).to receive(:shell_out!).with("emerge --unmerge --color n --nospinner --quiet =dev-util/git-1.0.0")
         @provider.remove_package("dev-util/git", "1.0.0")
       end
     end

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

@@ -30,55 +30,55 @@ describe Chef::Provider::Package::Rpm do
     @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
 
     @status = double("Status", :exitstatus => 0)
-    ::File.stub(:exists?).and_return(true)
+    allow(::File).to receive(:exists?).and_return(true)
   end
 
   describe "when determining the current state of the package" do
 
     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 == "ImageMagick-c++"
+      expect(@provider.current_resource.name).to eq("ImageMagick-c++")
     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 == 'ImageMagick-c++'
+      expect(@provider.current_resource.package_name).to eq('ImageMagick-c++')
     end
 
     it "should raise an exception if a source is supplied but not found" do
-      ::File.stub(:exists?).and_return(false)
-      lambda { @provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
+      allow(::File).to receive(:exists?).and_return(false)
+      expect { @provider.run_action(:any) }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should get the source package version from rpm if provided" do
       @stdout = StringIO.new("ImageMagick-c++ 6.5.4.7-7.el6_5")
-      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' ImageMagick-c++").and_return(@status)
+      expect(@provider).to receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' ImageMagick-c++").and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == "ImageMagick-c++"
-      @provider.new_resource.version.should == "6.5.4.7-7.el6_5"
+      expect(@provider.current_resource.package_name).to eq("ImageMagick-c++")
+      expect(@provider.new_resource.version).to eq("6.5.4.7-7.el6_5")
     end
 
     it "should return the current version installed if found by rpm" do
       @stdout = StringIO.new("ImageMagick-c++ 6.5.4.7-7.el6_5")
-      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm").and_return(@status)
-      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' ImageMagick-c++").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm").and_return(@status)
+      expect(@provider).to receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' ImageMagick-c++").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should == "6.5.4.7-7.el6_5"
+      expect(@provider.current_resource.version).to eq("6.5.4.7-7.el6_5")
     end
 
     it "should raise an exception if the source is not set but we are installing" do
       new_resource = Chef::Resource::Package.new("ImageMagick-c++")
       provider = Chef::Provider::Package::Rpm.new(new_resource, @run_context)
-      lambda { provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
+      expect { provider.run_action(:any) }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should raise an exception if rpm fails to run" do
       status = double("Status", :exitstatus => -1)
-      @provider.stub(:popen4).and_return(status)
-      lambda { @provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(status)
+      expect { @provider.run_action(:any) }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should not detect the package name as version when not installed" do
@@ -87,10 +87,10 @@ describe Chef::Provider::Package::Rpm do
       @new_resource = Chef::Resource::Package.new("openssh-askpass")
       @new_resource.source 'openssh-askpass'
       @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
-      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' openssh-askpass").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' openssh-askpass").and_return(@status)
+      expect(@provider).to receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' openssh-askpass").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' openssh-askpass").and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
   end
 
@@ -102,54 +102,54 @@ describe Chef::Provider::Package::Rpm do
 
     describe "when installing or upgrading" do
       it "should run rpm -i with the package source to install" do
-        @provider.should_receive(:shell_out!).with("rpm  -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
+        expect(@provider).to receive(:shell_out!).with("rpm  -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider.install_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
 
       it "should run rpm -U with the package source to upgrade" do
         @current_resource.version("21.4-19.el5")
-        @provider.should_receive(:shell_out!).with("rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
+        expect(@provider).to receive(:shell_out!).with("rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider.upgrade_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
 
       it "should install package if missing and set to upgrade" do
         @current_resource.version("ImageMagick-c++")
-        @provider.should_receive(:shell_out!).with("rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
+        expect(@provider).to receive(:shell_out!).with("rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider.upgrade_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
 
       it "should install from a path when the package is a path and the source is nil" do
         @new_resource = Chef::Resource::Package.new("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
-        @new_resource.source.should == "/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
+        expect(@new_resource.source).to eq("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @current_resource = Chef::Resource::Package.new("ImageMagick-c++")
         @provider.current_resource = @current_resource
-        @provider.should_receive(:shell_out!).with("rpm  -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
+        expect(@provider).to receive(:shell_out!).with("rpm  -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider.install_package("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm", "6.5.4.7-7.el6_5")
       end
 
       it "should uprgrade from a path when the package is a path and the source is nil" do
         @new_resource = Chef::Resource::Package.new("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
-        @new_resource.source.should == "/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
+        expect(@new_resource.source).to eq("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @current_resource = Chef::Resource::Package.new("ImageMagick-c++")
         @current_resource.version("21.4-19.el5")
         @provider.current_resource = @current_resource
-        @provider.should_receive(:shell_out!).with("rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
+        expect(@provider).to receive(:shell_out!).with("rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider.upgrade_package("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm", "6.5.4.7-7.el6_5")
       end
 
       it "installs with custom options specified in the resource" do
         @provider.candidate_version = '11'
         @new_resource.options("--dbpath /var/lib/rpm")
-        @provider.should_receive(:shell_out!).with("rpm --dbpath /var/lib/rpm -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
+        expect(@provider).to receive(:shell_out!).with("rpm --dbpath /var/lib/rpm -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider.install_package(@new_resource.name, @provider.candidate_version)
       end
     end
 
     describe "when removing the package" do
       it "should run rpm -e to remove the package" do
-        @provider.should_receive(:shell_out!).with("rpm  -e ImageMagick-c++-6.5.4.7-7.el6_5")
+        expect(@provider).to receive(:shell_out!).with("rpm  -e ImageMagick-c++-6.5.4.7-7.el6_5")
         @provider.remove_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
     end

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

@@ -39,23 +39,23 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
   end
 
   it "determines the gem paths from the in memory rubygems" do
-    @gem_env.gem_paths.should == Gem.path
+    expect(@gem_env.gem_paths).to eq(Gem.path)
   end
 
   it "determines the installed versions of gems from Gem.source_index" do
     gems = [gemspec('rspec-core', Gem::Version.new('1.2.9')), gemspec('rspec-core', Gem::Version.new('1.3.0'))]
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
-      Gem::Specification.should_receive(:find_all_by_name).with('rspec-core', Gem::Dependency.new('rspec-core').requirement).and_return(gems)
+      expect(Gem::Specification).to receive(:find_all_by_name).with('rspec-core', Gem::Dependency.new('rspec-core').requirement).and_return(gems)
     else
-      Gem.source_index.should_receive(:search).with(Gem::Dependency.new('rspec-core', nil)).and_return(gems)
+      expect(Gem.source_index).to receive(:search).with(Gem::Dependency.new('rspec-core', nil)).and_return(gems)
     end
-    @gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).should == gems
+    expect(@gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil))).to eq(gems)
   end
 
   it "determines the installed versions of gems from the source index (part2: the unmockening)" do
     expected = ['rspec-core', Gem::Version.new(RSpec::Core::Version::STRING)]
     actual = @gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).map { |spec| [spec.name, spec.version] }
-    actual.should include(expected)
+    expect(actual).to include(expected)
   end
 
   it "yields to a block with an alternate source list set" do
@@ -68,8 +68,8 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
       end
     rescue RuntimeError
     end
-    sources_in_block.should == %w{http://gems.example.org}
-    Gem.sources.should == normal_sources
+    expect(sources_in_block).to eq(%w{http://gems.example.org})
+    expect(Gem.sources).to eq(normal_sources)
   end
 
   it "it doesnt alter the gem sources if none are set" do
@@ -82,29 +82,29 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
       end
     rescue RuntimeError
     end
-    sources_in_block.should == normal_sources
-    Gem.sources.should == normal_sources
+    expect(sources_in_block).to eq(normal_sources)
+    expect(Gem.sources).to eq(normal_sources)
   end
 
   it "finds a matching gem candidate version" do
     dep = Gem::Dependency.new('rspec', '>= 0')
     dep_installer = Gem::DependencyInstaller.new
-    @gem_env.stub(:dependency_installer).and_return(dep_installer)
+    allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     latest = [[gemspec("rspec", Gem::Version.new("1.3.0")), "http://rubygems.org/"]]
-    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(latest)
-    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0')).should == Gem::Version.new('1.3.0')
+    expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(latest)
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0'))).to eq(Gem::Version.new('1.3.0'))
   end
 
   it "finds a matching gem candidate version on rubygems 2.0.0+" do
     dep = Gem::Dependency.new('rspec', '>= 0')
     dep_installer = Gem::DependencyInstaller.new
-    @gem_env.stub(:dependency_installer).and_return(dep_installer)
+    allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
     best_gem = double("best gem match", :spec => gemspec("rspec", Gem::Version.new("1.3.0")), :source => "https://rubygems.org")
     available_set = double("Gem::AvailableSet test double")
-    available_set.should_receive(:pick_best!)
-    available_set.should_receive(:set).and_return([best_gem])
-    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(available_set)
-    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0')).should == Gem::Version.new('1.3.0')
+    expect(available_set).to receive(:pick_best!)
+    expect(available_set).to receive(:set).and_return([best_gem])
+    expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(available_set)
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0'))).to eq(Gem::Version.new('1.3.0'))
   end
 
   context "when rubygems was upgraded from 1.8->2.0" do
@@ -121,7 +121,7 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
         Gem.const_set(:Format, Object.new)
         @remove_gem_format = true
       end
-      Gem::Package.stub(:respond_to?).with(:open).and_return(false)
+      allow(Gem::Package).to receive(:respond_to?).with(:open).and_return(false)
     end
 
     after do
@@ -132,8 +132,8 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
 
     it "finds a matching gem candidate version on rubygems 2.0+ with some rubygems 1.8 code loaded" do
       package = double("Gem::Package", :spec => "a gemspec from package")
-      Gem::Package.should_receive(:new).with("/path/to/package.gem").and_return(package)
-      @gem_env.spec_from_file("/path/to/package.gem").should == "a gemspec from package"
+      expect(Gem::Package).to receive(:new).with("/path/to/package.gem").and_return(package)
+      expect(@gem_env.spec_from_file("/path/to/package.gem")).to eq("a gemspec from package")
     end
 
   end
@@ -142,54 +142,54 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
     dep = Gem::Dependency.new('rspec', '>= 0')
     latest = []
     dep_installer = Gem::DependencyInstaller.new
-    @gem_env.stub(:dependency_installer).and_return(dep_installer)
-    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(latest)
-    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0')).should be_nil
+    allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
+    expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(latest)
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>= 0'))).to be_nil
   end
 
   it "finds a matching candidate version from a .gem file when the path to the gem is supplied" do
     location = CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
-    @gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0'), location).should == Gem::Version.new('0.1.0')
-    @gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0.2.0'), location).should be_nil
+    expect(@gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0'), location)).to eq(Gem::Version.new('0.1.0'))
+    expect(@gem_env.candidate_version_from_file(Gem::Dependency.new('chef-integration-test', '>= 0.2.0'), location)).to be_nil
   end
 
   it "finds a matching gem from a specific gemserver when explicit sources are given" do
     dep = Gem::Dependency.new('rspec', '>= 0')
     latest = [[gemspec("rspec", Gem::Version.new("1.3.0")), "http://rubygems.org/"]]
 
-    @gem_env.should_receive(:with_gem_sources).with('http://gems.example.com').and_yield
+    expect(@gem_env).to receive(:with_gem_sources).with('http://gems.example.com').and_yield
     dep_installer = Gem::DependencyInstaller.new
-    @gem_env.stub(:dependency_installer).and_return(dep_installer)
-    dep_installer.should_receive(:find_gems_with_sources).with(dep).and_return(latest)
-    @gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>=0'), 'http://gems.example.com').should == Gem::Version.new('1.3.0')
+    allow(@gem_env).to receive(:dependency_installer).and_return(dep_installer)
+    expect(dep_installer).to receive(:find_gems_with_sources).with(dep).and_return(latest)
+    expect(@gem_env.candidate_version_from_remote(Gem::Dependency.new('rspec', '>=0'), 'http://gems.example.com')).to eq(Gem::Version.new('1.3.0'))
   end
 
   it "installs a gem with a hash of options for the dependency installer" do
     dep_installer = Gem::DependencyInstaller.new
-    @gem_env.should_receive(:dependency_installer).with(:install_dir => '/foo/bar').and_return(dep_installer)
-    @gem_env.should_receive(:with_gem_sources).with('http://gems.example.com').and_yield
-    dep_installer.should_receive(:install).with(Gem::Dependency.new('rspec', '>= 0'))
+    expect(@gem_env).to receive(:dependency_installer).with(:install_dir => '/foo/bar').and_return(dep_installer)
+    expect(@gem_env).to receive(:with_gem_sources).with('http://gems.example.com').and_yield
+    expect(dep_installer).to receive(:install).with(Gem::Dependency.new('rspec', '>= 0'))
     @gem_env.install(Gem::Dependency.new('rspec', '>= 0'), :install_dir => '/foo/bar', :sources => ['http://gems.example.com'])
   end
 
   it "builds an uninstaller for a gem with options set to avoid requiring user input" do
     # default options for uninstaller should be:
     # :ignore => true, :executables => true
-    Gem::Uninstaller.should_receive(:new).with('rspec', :ignore => true, :executables => true)
+    expect(Gem::Uninstaller).to receive(:new).with('rspec', :ignore => true, :executables => true)
     @gem_env.uninstaller('rspec')
   end
 
   it "uninstalls all versions of a gem" do
     uninstaller = double('gem uninstaller')
-    uninstaller.should_receive(:uninstall)
-    @gem_env.should_receive(:uninstaller).with('rspec', :all => true).and_return(uninstaller)
+    expect(uninstaller).to receive(:uninstall)
+    expect(@gem_env).to receive(:uninstaller).with('rspec', :all => true).and_return(uninstaller)
     @gem_env.uninstall('rspec')
   end
 
   it "uninstalls a specific version of a gem" do
     uninstaller = double('gem uninstaller')
-    uninstaller.should_receive(:uninstall)
-    @gem_env.should_receive(:uninstaller).with('rspec', :version => '1.2.3').and_return(uninstaller)
+    expect(uninstaller).to receive(:uninstall)
+    expect(@gem_env).to receive(:uninstaller).with('rspec', :version => '1.2.3').and_return(uninstaller)
     @gem_env.uninstall('rspec', '1.2.3')
   end
 
@@ -207,35 +207,35 @@ describe Chef::Provider::Package::Rubygems::AlternateGemEnvironment do
   it "determines the gem paths from shelling out to gem env" do
     gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
     shell_out_result = OpenStruct.new(:stdout => gem_env_output)
-    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
-    @gem_env.gem_paths.should == ['/path/to/gems', '/another/path/to/gems']
+    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
+    expect(@gem_env.gem_paths).to eq(['/path/to/gems', '/another/path/to/gems'])
   end
 
   it "caches the gempaths by gem_binary" do
     gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
     shell_out_result = OpenStruct.new(:stdout => gem_env_output)
-    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
+    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env gempath').and_return(shell_out_result)
     expected = ['/path/to/gems', '/another/path/to/gems']
-    @gem_env.gem_paths.should == ['/path/to/gems', '/another/path/to/gems']
-    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem'].should == expected
+    expect(@gem_env.gem_paths).to eq(['/path/to/gems', '/another/path/to/gems'])
+    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem']).to eq(expected)
   end
 
   it "uses the cached result for gem paths when available" do
     gem_env_output = ['/path/to/gems', '/another/path/to/gems'].join(File::PATH_SEPARATOR)
     shell_out_result = OpenStruct.new(:stdout => gem_env_output)
-    @gem_env.should_not_receive(:shell_out!)
+    expect(@gem_env).not_to receive(:shell_out!)
     expected = ['/path/to/gems', '/another/path/to/gems']
     Chef::Provider::Package::Rubygems::AlternateGemEnvironment.gempath_cache['/usr/weird/bin/gem']= expected
-    @gem_env.gem_paths.should == ['/path/to/gems', '/another/path/to/gems']
+    expect(@gem_env.gem_paths).to eq(['/path/to/gems', '/another/path/to/gems'])
   end
 
   it "builds the gems source index from the gem paths" do
-    @gem_env.stub(:gem_paths).and_return(['/path/to/gems', '/another/path/to/gems'])
+    allow(@gem_env).to receive(:gem_paths).and_return(['/path/to/gems', '/another/path/to/gems'])
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
       @gem_env.gem_specification
-      Gem::Specification.dirs.should == [ '/path/to/gems/specifications', '/another/path/to/gems/specifications' ]
+      expect(Gem::Specification.dirs).to eq([ '/path/to/gems/specifications', '/another/path/to/gems/specifications' ])
     else
-      Gem::SourceIndex.should_receive(:from_gems_in).with('/path/to/gems/specifications', '/another/path/to/gems/specifications')
+      expect(Gem::SourceIndex).to receive(:from_gems_in).with('/path/to/gems/specifications', '/another/path/to/gems/specifications')
       @gem_env.gem_source_index
     end
   end
@@ -244,17 +244,17 @@ describe Chef::Provider::Package::Rubygems::AlternateGemEnvironment do
     gems = [gemspec('rspec', Gem::Version.new('1.2.9')), gemspec('rspec', Gem::Version.new('1.3.0'))]
     rspec_dep = Gem::Dependency.new('rspec', nil)
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
-      @gem_env.stub(:gem_specification).and_return(Gem::Specification)
-      @gem_env.gem_specification.should_receive(:find_all_by_name).with(rspec_dep.name, rspec_dep.requirement).and_return(gems)
+      allow(@gem_env).to receive(:gem_specification).and_return(Gem::Specification)
+      expect(@gem_env.gem_specification).to receive(:find_all_by_name).with(rspec_dep.name, rspec_dep.requirement).and_return(gems)
     else
-      @gem_env.stub(:gem_source_index).and_return(Gem.source_index)
-      @gem_env.gem_source_index.should_receive(:search).with(rspec_dep).and_return(gems)
+      allow(@gem_env).to receive(:gem_source_index).and_return(Gem.source_index)
+      expect(@gem_env.gem_source_index).to receive(:search).with(rspec_dep).and_return(gems)
     end
-    @gem_env.installed_versions(Gem::Dependency.new('rspec', nil)).should == gems
+    expect(@gem_env.installed_versions(Gem::Dependency.new('rspec', nil))).to eq(gems)
   end
 
   it "determines the installed versions of gems from the source index (part2: the unmockening)" do
-    $stdout.stub(:write)
+    allow($stdout).to receive(:write)
     path_to_gem = if windows?
       `where gem`.split[1]
     else
@@ -264,7 +264,7 @@ describe Chef::Provider::Package::Rubygems::AlternateGemEnvironment do
     gem_env = Chef::Provider::Package::Rubygems::AlternateGemEnvironment.new(path_to_gem)
     expected = ['rspec-core', Gem::Version.new(RSpec::Core::Version::STRING)]
     actual = gem_env.installed_versions(Gem::Dependency.new('rspec-core', nil)).map { |s| [s.name, s.version] }
-    actual.should include(expected)
+    expect(actual).to include(expected)
   end
 
   it "detects when the target gem environment is the jruby platform" do
@@ -295,18 +295,18 @@ RubyGems Environment:
      - http://rubygems.org/
      - http://gems.github.com/
 JRUBY_GEM_ENV
-    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(double('jruby_gem_env', :stdout => gem_env_out))
+    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(double('jruby_gem_env', :stdout => gem_env_out))
     expected = ['ruby', Gem::Platform.new('universal-java-1.6')]
-    @gem_env.gem_platforms.should == expected
+    expect(@gem_env.gem_platforms).to eq(expected)
     # it should also cache the result
-    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem'].should == expected
+    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']).to eq(expected)
   end
 
   it "uses the cached result for gem platforms if available" do
-    @gem_env.should_not_receive(:shell_out!)
+    expect(@gem_env).not_to receive(:shell_out!)
     expected = ['ruby', Gem::Platform.new('universal-java-1.6')]
     Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']= expected
-    @gem_env.gem_platforms.should == expected
+    expect(@gem_env.gem_platforms).to eq(expected)
   end
 
   it "uses the current gem platforms when the target env is not jruby" do
@@ -337,9 +337,9 @@ RubyGems Environment:
      - http://rubygems.org/
      - http://gems.github.com/
 RBX_GEM_ENV
-    @gem_env.should_receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(double('rbx_gem_env', :stdout => gem_env_out))
-    @gem_env.gem_platforms.should == Gem.platforms
-    Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem'].should == Gem.platforms
+    expect(@gem_env).to receive(:shell_out!).with('/usr/weird/bin/gem env').and_return(double('rbx_gem_env', :stdout => gem_env_out))
+    expect(@gem_env.gem_platforms).to eq(Gem.platforms)
+    expect(Chef::Provider::Package::Rubygems::AlternateGemEnvironment.platform_cache['/usr/weird/bin/gem']).to eq(Gem.platforms)
   end
 
   it "yields to a block while masquerading as a different gems platform" do
@@ -352,288 +352,302 @@ RBX_GEM_ENV
       end
     rescue RuntimeError
     end
-    platforms_in_block.should == ['ruby', Gem::Platform.new('sparc64-java-1.7')]
-    Gem.platforms.should == original_platforms
+    expect(platforms_in_block).to eq(['ruby', Gem::Platform.new('sparc64-java-1.7')])
+    expect(Gem.platforms).to eq(original_platforms)
   end
 
 end
 
 describe Chef::Provider::Package::Rubygems do
+  let(:target_version) { nil }
+
   before(:each) do
     @node = Chef::Node.new
     @new_resource = Chef::Resource::GemPackage.new("rspec-core")
-    @spec_version = @new_resource.version RSpec::Core::Version::STRING
+    @spec_version = @new_resource.version(target_version)
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
     # We choose detect omnibus via RbConfig::CONFIG['bindir'] in Chef::Provider::Package::Rubygems.new
-    RbConfig::CONFIG.stub(:[]).with('bindir').and_return("/usr/bin/ruby")
+    allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/usr/bin/ruby")
     @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
   end
 
-  it "triggers a gem configuration load so a later one will not stomp its config values" do
-    # ugly, is there a better way?
-    Gem.instance_variable_get(:@configuration).should_not be_nil
-  end
+  describe "when new_resource version is nil" do
+    let(:target_version) { nil }
 
-  it "uses the CurrentGemEnvironment implementation when no gem_binary_path is provided" do
-    @provider.gem_env.should be_a_kind_of(Chef::Provider::Package::Rubygems::CurrentGemEnvironment)
+    it "target_version_already_installed? should return false so that we can search for candidates" do
+      @provider.load_current_resource
+      expect(@provider.target_version_already_installed?).to be_false
+    end
   end
 
-  it "uses the AlternateGemEnvironment implementation when a gem_binary_path is provided" do
-    @new_resource.gem_binary('/usr/weird/bin/gem')
-    provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-    provider.gem_env.gem_binary_location.should == '/usr/weird/bin/gem'
-  end
+  describe "when new_resource version is current rspec version" do
+    let(:target_version) { RSpec::Core::Version::STRING }
 
-  it "searches for a gem binary when running on Omnibus on Unix" do
-    platform_mock :unix do
-      RbConfig::CONFIG.stub(:[]).with('bindir').and_return("/opt/chef/embedded/bin")
-      ENV.stub(:[]).with('PATH').and_return("/usr/bin:/usr/sbin:/opt/chef/embedded/bin")
-      File.stub(:exists?).with('/usr/bin/gem').and_return(false)
-      File.stub(:exists?).with('/usr/sbin/gem').and_return(true)
-      File.stub(:exists?).with('/opt/chef/embedded/bin/gem').and_return(true) # should not get here
-      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-      provider.gem_env.gem_binary_location.should == '/usr/sbin/gem'
+    it "triggers a gem configuration load so a later one will not stomp its config values" do
+      # ugly, is there a better way?
+      expect(Gem.instance_variable_get(:@configuration)).not_to be_nil
     end
-  end
 
-  it "searches for a gem binary when running on Omnibus on Windows" do
-    platform_mock :windows do
-      RbConfig::CONFIG.stub(:[]).with('bindir').and_return("d:/opscode/chef/embedded/bin")
-      ENV.stub(:[]).with('PATH').and_return('C:\windows\system32;C:\windows;C:\Ruby186\bin;d:\opscode\chef\embedded\bin')
-      File.stub(:exists?).with('C:\\windows\\system32\\gem').and_return(false)
-      File.stub(:exists?).with('C:\\windows\\gem').and_return(false)
-      File.stub(:exists?).with('C:\\Ruby186\\bin\\gem').and_return(true)
-      File.stub(:exists?).with('d:\\opscode\\chef\\bin\\gem').and_return(false) # should not get here
-      File.stub(:exists?).with('d:\\opscode\\chef\\embedded\\bin\\gem').and_return(false) # should not get here
-      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-      provider.gem_env.gem_binary_location.should == 'C:\Ruby186\bin\gem'
+    it "uses the CurrentGemEnvironment implementation when no gem_binary_path is provided" do
+      expect(@provider.gem_env).to be_a_kind_of(Chef::Provider::Package::Rubygems::CurrentGemEnvironment)
     end
-  end
 
-  it "smites you when you try to use a hash of install options with an explicit gem binary" do
-    @new_resource.gem_binary('/foo/bar')
-    @new_resource.options(:fail => :burger)
-    lambda {Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)}.should raise_error(ArgumentError)
-  end
-
-  it "converts the new resource into a gem dependency" do
-    @provider.gem_dependency.should == Gem::Dependency.new('rspec-core', @spec_version)
-    @new_resource.version('~> 1.2.0')
-    @provider.gem_dependency.should == Gem::Dependency.new('rspec-core', '~> 1.2.0')
-  end
+    it "uses the AlternateGemEnvironment implementation when a gem_binary_path is provided" do
+      @new_resource.gem_binary('/usr/weird/bin/gem')
+      provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+      expect(provider.gem_env.gem_binary_location).to eq('/usr/weird/bin/gem')
+    end
 
-  describe "when determining the currently installed version" do
+    it "searches for a gem binary when running on Omnibus on Unix" do
+      platform_mock :unix do
+        allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("/opt/chef/embedded/bin")
+        allow(ENV).to receive(:[]).with('PATH').and_return("/usr/bin:/usr/sbin:/opt/chef/embedded/bin")
+        allow(File).to receive(:exists?).with('/usr/bin/gem').and_return(false)
+        allow(File).to receive(:exists?).with('/usr/sbin/gem').and_return(true)
+        allow(File).to receive(:exists?).with('/opt/chef/embedded/bin/gem').and_return(true) # should not get here
+        provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+        expect(provider.gem_env.gem_binary_location).to eq('/usr/sbin/gem')
+      end
+    end
 
-    it "sets the current version to the version specified by the new resource if that version is installed" do
-      @provider.load_current_resource
-      @provider.current_resource.version.should == @spec_version
+    it "searches for a gem binary when running on Omnibus on Windows" do
+      platform_mock :windows do
+        allow(RbConfig::CONFIG).to receive(:[]).with('bindir').and_return("d:/opscode/chef/embedded/bin")
+        allow(ENV).to receive(:[]).with('PATH').and_return('C:\windows\system32;C:\windows;C:\Ruby186\bin;d:\opscode\chef\embedded\bin')
+        allow(File).to receive(:exists?).with('C:\\windows\\system32\\gem').and_return(false)
+        allow(File).to receive(:exists?).with('C:\\windows\\gem').and_return(false)
+        allow(File).to receive(:exists?).with('C:\\Ruby186\\bin\\gem').and_return(true)
+        allow(File).to receive(:exists?).with('d:\\opscode\\chef\\bin\\gem').and_return(false) # should not get here
+        allow(File).to receive(:exists?).with('d:\\opscode\\chef\\embedded\\bin\\gem').and_return(false) # should not get here
+        provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+        expect(provider.gem_env.gem_binary_location).to eq('C:\Ruby186\bin\gem')
+      end
     end
 
-    it "sets the current version to the highest installed version if the requested version is not installed" do
-      @new_resource.version('9000.0.2')
-      @provider.load_current_resource
-      @provider.current_resource.version.should == @spec_version
+    it "smites you when you try to use a hash of install options with an explicit gem binary" do
+      @new_resource.gem_binary('/foo/bar')
+      @new_resource.options(:fail => :burger)
+      expect {Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)}.to raise_error(ArgumentError)
     end
 
-    it "leaves the current version at nil if the package is not installed" do
-      @new_resource.package_name("no-such-gem-should-exist-with-this-name")
-      @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+    it "converts the new resource into a gem dependency" do
+      expect(@provider.gem_dependency).to eq(Gem::Dependency.new('rspec-core', @spec_version))
+      @new_resource.version('~> 1.2.0')
+      expect(@provider.gem_dependency).to eq(Gem::Dependency.new('rspec-core', '~> 1.2.0'))
     end
 
-  end
+    describe "when determining the currently installed version" do
 
-  describe "when determining the candidate version to install" do
+      it "sets the current version to the version specified by the new resource if that version is installed" do
+        @provider.load_current_resource
+        expect(@provider.current_resource.version).to eq(@spec_version)
+      end
 
-    it "does not query for available versions when the current version is the target version" do
-      @provider.current_resource = @new_resource.dup
-      @provider.candidate_version.should be_nil
-    end
+      it "sets the current version to the highest installed version if the requested version is not installed" do
+        @new_resource.version('9000.0.2')
+        @provider.load_current_resource
+        expect(@provider.current_resource.version).to eq(@spec_version)
+      end
 
-    it "determines the candidate version by querying the remote gem servers" do
-      @new_resource.source('http://mygems.example.com')
-      version = Gem::Version.new(@spec_version)
-      @provider.gem_env.should_receive(:candidate_version_from_remote).
-                        with(Gem::Dependency.new('rspec-core', @spec_version), "http://mygems.example.com").
-                        and_return(version)
-      @provider.candidate_version.should == @spec_version
-    end
+      it "leaves the current version at nil if the package is not installed" do
+        @new_resource.package_name("no-such-gem-should-exist-with-this-name")
+        @provider.load_current_resource
+        expect(@provider.current_resource.version).to be_nil
+      end
 
-    it "parses the gem's specification if the requested source is a file" do
-      @new_resource.package_name('chef-integration-test')
-      @new_resource.version('>= 0')
-      @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-      @provider.candidate_version.should == '0.1.0'
     end
 
-  end
-
-  describe "when installing a gem" do
-    before do
-      @current_resource = Chef::Resource::GemPackage.new('rspec-core')
-      @provider.current_resource = @current_resource
-      @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
-      @provider.stub(:load_current_resource)
-    end
+    describe "when determining the candidate version to install" do
 
-    describe "in the current gem environment" do
-      it "installs the gem via the gems api when no explicit options are used" do
-        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil)
-        @provider.action_install.should be_true
+      it "does not query for available versions when the current version is the target version" do
+        @provider.current_resource = @new_resource.dup
+        expect(@provider.candidate_version).to be_nil
       end
 
-      it "installs the gem via the gems api when a remote source is provided" do
-        @new_resource.source('http://gems.example.org')
-        sources = ['http://gems.example.org']
-        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => sources)
-        @provider.action_install.should be_true
+      it "determines the candidate version by querying the remote gem servers" do
+        @new_resource.source('http://mygems.example.com')
+        version = Gem::Version.new(@spec_version)
+        expect(@provider.gem_env).to receive(:candidate_version_from_remote).
+                          with(Gem::Dependency.new('rspec-core', @spec_version), "http://mygems.example.com").
+                          and_return(version)
+        expect(@provider.candidate_version).to eq(@spec_version)
       end
 
-      it "installs the gem from file via the gems api when no explicit options are used" do
+      it "parses the gem's specification if the requested source is a file" do
+        @new_resource.package_name('chef-integration-test')
+        @new_resource.version('>= 0')
         @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @provider.gem_env.should_receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @provider.action_install.should be_true
+        expect(@provider.candidate_version).to eq('0.1.0')
       end
 
-      it "installs the gem from file via the gems api when the package is a path and the source is nil" do
-        @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+    end
+
+    describe "when installing a gem" do
+      before do
+        @current_resource = Chef::Resource::GemPackage.new('rspec-core')
         @provider.current_resource = @current_resource
-        @new_resource.source.should == CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
-        @provider.gem_env.should_receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @provider.action_install.should be_true
+        @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
+        allow(@provider).to receive(:load_current_resource)
       end
 
-      # this catches 'gem_package "foo"' when "./foo" is a file in the cwd, and instead of installing './foo' it fetches the remote gem
-      it "installs the gem via the gems api, when the package has no file separator characters in it, but a matching file exists in cwd" do
-        ::File.stub(:exists?).and_return(true)
-        @new_resource.package_name('rspec-core')
-        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil)
-        @provider.action_install.should be_true
-      end
+      describe "in the current gem environment" do
+        it "installs the gem via the gems api when no explicit options are used" do
+          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil)
+          expect(@provider.action_install).to be_true
+        end
 
-      it "installs the gem by shelling out when options are provided as a String" do
-        @new_resource.options('-i /alt/install/location')
-        expected ="gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\" -i /alt/install/location"
-        @provider.should_receive(:shell_out!).with(expected, :env => nil)
-        @provider.action_install.should be_true
-      end
+        it "installs the gem via the gems api when a remote source is provided" do
+          @new_resource.source('http://gems.example.org')
+          sources = ['http://gems.example.org']
+          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => sources)
+          expect(@provider.action_install).to be_true
+        end
 
-      it "installs the gem via the gems api when options are given as a Hash" do
-        @new_resource.options(:install_dir => '/alt/install/location')
-        @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil, :install_dir => '/alt/install/location')
-        @provider.action_install.should be_true
-      end
+        it "installs the gem from file via the gems api when no explicit options are used" do
+          @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          expect(@provider.gem_env).to receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          expect(@provider.action_install).to be_true
+        end
 
-      describe "at a specific version" do
-        before do
-          @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
+        it "installs the gem from file via the gems api when the package is a path and the source is nil" do
+          @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+          @provider.current_resource = @current_resource
+          expect(@new_resource.source).to eq(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          expect(@provider.gem_env).to receive(:install).with(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          expect(@provider.action_install).to be_true
         end
 
-        it "installs the gem via the gems api" do
-          @provider.gem_env.should_receive(:install).with(@gem_dep, :sources => nil)
-          @provider.action_install.should be_true
+        # this catches 'gem_package "foo"' when "./foo" is a file in the cwd, and instead of installing './foo' it fetches the remote gem
+        it "installs the gem via the gems api, when the package has no file separator characters in it, but a matching file exists in cwd" do
+          allow(::File).to receive(:exists?).and_return(true)
+          @new_resource.package_name('rspec-core')
+          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil)
+          expect(@provider.action_install).to be_true
+        end
+
+        it "installs the gem by shelling out when options are provided as a String" do
+          @new_resource.options('-i /alt/install/location')
+          expected ="gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\" -i /alt/install/location"
+          expect(@provider).to receive(:shell_out!).with(expected, :env => nil)
+          expect(@provider.action_install).to be_true
         end
-      end
-      describe "at version specified with comparison operator" do
-        it "skips install if current version satisifies requested version" do
-          @current_resource.stub(:version).and_return("2.3.3")
-          @new_resource.stub(:version).and_return(">=2.3.0")
 
-          @provider.gem_env.should_not_receive(:install)
-          @provider.action_install
+        it "installs the gem via the gems api when options are given as a Hash" do
+          @new_resource.options(:install_dir => '/alt/install/location')
+          expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil, :install_dir => '/alt/install/location')
+          expect(@provider.action_install).to be_true
         end
 
-        it "allows user to specify gem version with fuzzy operator" do
-          @current_resource.stub(:version).and_return("2.3.3")
-          @new_resource.stub(:version).and_return("~>2.3.0")
+        describe "at a specific version" do
+          before do
+            @gem_dep = Gem::Dependency.new('rspec-core', @spec_version)
+          end
 
-          @provider.gem_env.should_not_receive(:install)
-          @provider.action_install
+          it "installs the gem via the gems api" do
+            expect(@provider.gem_env).to receive(:install).with(@gem_dep, :sources => nil)
+            expect(@provider.action_install).to be_true
+          end
+        end
+        describe "at version specified with comparison operator" do
+          it "skips install if current version satisifies requested version" do
+            allow(@current_resource).to receive(:version).and_return("2.3.3")
+            allow(@new_resource).to receive(:version).and_return(">=2.3.0")
+
+            expect(@provider.gem_env).not_to receive(:install)
+            @provider.action_install
+          end
+
+          it "allows user to specify gem version with fuzzy operator" do
+            allow(@current_resource).to receive(:version).and_return("2.3.3")
+            allow(@new_resource).to receive(:version).and_return("~>2.3.0")
+
+            expect(@provider.gem_env).not_to receive(:install)
+            @provider.action_install
+          end
         end
       end
-    end
 
-    describe "in an alternate gem environment" do
-      it "installs the gem by shelling out to gem install" do
-        @new_resource.gem_binary('/usr/weird/bin/gem')
-        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\"", :env=>nil)
-        @provider.action_install.should be_true
-      end
+      describe "in an alternate gem environment" do
+        it "installs the gem by shelling out to gem install" do
+          @new_resource.gem_binary('/usr/weird/bin/gem')
+          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem install rspec-core -q --no-rdoc --no-ri -v \"#{@spec_version}\"", :env=>nil)
+          expect(@provider.action_install).to be_true
+        end
 
-      it "installs the gem from file by shelling out to gem install" do
-        @new_resource.gem_binary('/usr/weird/bin/gem')
-        @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @new_resource.version('>= 0')
-        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", :env=>nil)
-        @provider.action_install.should be_true
-      end
+        it "installs the gem from file by shelling out to gem install" do
+          @new_resource.gem_binary('/usr/weird/bin/gem')
+          @new_resource.source(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          @new_resource.version('>= 0')
+          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", :env=>nil)
+          expect(@provider.action_install).to be_true
+        end
 
-      it "installs the gem from file by shelling out to gem install when the package is a path and the source is nil" do
-        @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
-        @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
-        @provider.current_resource = @current_resource
-        @new_resource.gem_binary('/usr/weird/bin/gem')
-        @new_resource.version('>= 0')
-        @new_resource.source.should == CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem'
-        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", :env=>nil)
-        @provider.action_install.should be_true
+        it "installs the gem from file by shelling out to gem install when the package is a path and the source is nil" do
+          @new_resource = Chef::Resource::GemPackage.new(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          @provider = Chef::Provider::Package::Rubygems.new(@new_resource, @run_context)
+          @provider.current_resource = @current_resource
+          @new_resource.gem_binary('/usr/weird/bin/gem')
+          @new_resource.version('>= 0')
+          expect(@new_resource.source).to eq(CHEF_SPEC_DATA + '/gems/chef-integration-test-0.1.0.gem')
+          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem install #{CHEF_SPEC_DATA}/gems/chef-integration-test-0.1.0.gem -q --no-rdoc --no-ri -v \">= 0\"", :env=>nil)
+          expect(@provider.action_install).to be_true
+        end
       end
-    end
-
-  end
 
-  describe "when uninstalling a gem" do
-    before do
-      @new_resource = Chef::Resource::GemPackage.new("rspec")
-      @current_resource = @new_resource.dup
-      @current_resource.version('1.2.3')
-      @provider.new_resource = @new_resource
-      @provider.current_resource = @current_resource
     end
 
-    describe "in the current gem environment" do
-      it "uninstalls via the api when no explicit options are used" do
-        # pre-reqs for action_remove to actually remove the package:
-        @provider.new_resource.version.should be_nil
-        @provider.current_resource.version.should_not be_nil
-        # the behavior we're testing:
-        @provider.gem_env.should_receive(:uninstall).with('rspec', nil)
-        @provider.action_remove
+    describe "when uninstalling a gem" do
+      before do
+        @new_resource = Chef::Resource::GemPackage.new("rspec")
+        @current_resource = @new_resource.dup
+        @current_resource.version('1.2.3')
+        @provider.new_resource = @new_resource
+        @provider.current_resource = @current_resource
       end
 
-      it "uninstalls via the api when options are given as a Hash" do
-        # pre-reqs for action_remove to actually remove the package:
-        @provider.new_resource.version.should be_nil
-        @provider.current_resource.version.should_not be_nil
-        # the behavior we're testing:
-        @new_resource.options(:install_dir => '/alt/install/location')
-        @provider.gem_env.should_receive(:uninstall).with('rspec', nil, :install_dir => '/alt/install/location')
-        @provider.action_remove
-      end
+      describe "in the current gem environment" do
+        it "uninstalls via the api when no explicit options are used" do
+          # pre-reqs for action_remove to actually remove the package:
+          expect(@provider.new_resource.version).to be_nil
+          expect(@provider.current_resource.version).not_to be_nil
+          # the behavior we're testing:
+          expect(@provider.gem_env).to receive(:uninstall).with('rspec', nil)
+          @provider.action_remove
+        end
 
-      it "uninstalls via the gem command when options are given as a String" do
-        @new_resource.options('-i /alt/install/location')
-        @provider.should_receive(:shell_out!).with("gem uninstall rspec -q -x -I -a -i /alt/install/location", :env=>nil)
-        @provider.action_remove
-      end
+        it "uninstalls via the api when options are given as a Hash" do
+          # pre-reqs for action_remove to actually remove the package:
+          expect(@provider.new_resource.version).to be_nil
+          expect(@provider.current_resource.version).not_to be_nil
+          # the behavior we're testing:
+          @new_resource.options(:install_dir => '/alt/install/location')
+          expect(@provider.gem_env).to receive(:uninstall).with('rspec', nil, :install_dir => '/alt/install/location')
+          @provider.action_remove
+        end
+
+        it "uninstalls via the gem command when options are given as a String" do
+          @new_resource.options('-i /alt/install/location')
+          expect(@provider).to receive(:shell_out!).with("gem uninstall rspec -q -x -I -a -i /alt/install/location", :env=>nil)
+          @provider.action_remove
+        end
 
-      it "uninstalls a specific version of a gem when a version is provided" do
-        @new_resource.version('1.2.3')
-        @provider.gem_env.should_receive(:uninstall).with('rspec', '1.2.3')
-        @provider.action_remove
+        it "uninstalls a specific version of a gem when a version is provided" do
+          @new_resource.version('1.2.3')
+          expect(@provider.gem_env).to receive(:uninstall).with('rspec', '1.2.3')
+          @provider.action_remove
+        end
       end
-    end
 
-    describe "in an alternate gem environment" do
-      it "uninstalls via the gem command" do
-        @new_resource.gem_binary('/usr/weird/bin/gem')
-        @provider.should_receive(:shell_out!).with("/usr/weird/bin/gem uninstall rspec -q -x -I -a", :env=>nil)
-        @provider.action_remove
+      describe "in an alternate gem environment" do
+        it "uninstalls via the gem command" do
+          @new_resource.gem_binary('/usr/weird/bin/gem')
+          expect(@provider).to receive(:shell_out!).with("/usr/weird/bin/gem uninstall rspec -q -x -I -a", :env=>nil)
+          @provider.action_remove
+        end
       end
     end
   end
 end
-