chef 12.0.0.alpha.2 → 12.0.0.rc.0

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

@@ -33,32 +33,32 @@ describe Chef::Provider::Package::Dpkg do
     @status = double("Status", :exitstatus => 0)
     @stderr = StringIO.new
     @pid = double("PID")
-    @provider.stub(:popen4).and_return(@status)
+    allow(@provider).to receive(:popen4).and_return(@status)
 
-    ::File.stub(:exists?).and_return(true)
+    allow(::File).to receive(:exists?).and_return(true)
   end
 
   describe "when loading the current resource state" do
 
     it "should create a current resource with the name of the new_resource" do
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == "wget"
+      expect(@provider.current_resource.package_name).to eq("wget")
     end
 
     it "should raise an exception if a source is supplied but not found" do
       @provider.load_current_resource
       @provider.define_resource_requirements
-      ::File.stub(:exists?).and_return(false)
-      lambda { @provider.run_action(:install) }.should raise_error(Chef::Exceptions::Package)
+      allow(::File).to receive(:exists?).and_return(false)
+      expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
 
     describe 'gets the source package version from dpkg-deb' do
       def check_version(version)
         @stdout = StringIO.new("wget\t#{version}")
-        @provider.stub(:popen4).with("dpkg-deb -W #{@new_resource.source}").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        allow(@provider).to receive(:popen4).with("dpkg-deb -W #{@new_resource.source}").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
         @provider.load_current_resource
-        @provider.current_resource.package_name.should == "wget"
-        @new_resource.version.should == version
+        expect(@provider.current_resource.package_name).to eq("wget")
+        expect(@new_resource.version).to eq(version)
       end
 
       it 'if short version provided' do
@@ -80,9 +80,9 @@ describe Chef::Provider::Package::Dpkg do
 
     it "gets the source package name from dpkg-deb correctly when the package name has `-', `+' or `.' characters" do
       @stdout = StringIO.new("f.o.o-pkg++2\t1.11.4-1ubuntu1")
-      @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      allow(@provider).to receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == "f.o.o-pkg++2"
+      expect(@provider.current_resource.package_name).to eq("f.o.o-pkg++2")
     end
 
     it "should raise an exception if the source is not set but we are installing" do
@@ -90,7 +90,7 @@ describe Chef::Provider::Package::Dpkg do
       @provider.new_resource = @new_resource
       @provider.define_resource_requirements
       @provider.load_current_resource
-      lambda { @provider.run_action(:install)}.should raise_error(Chef::Exceptions::Package)
+      expect { @provider.run_action(:install)}.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should return the current version installed if found by dpkg" do
@@ -107,22 +107,22 @@ Config-Version: 1.11.4-1ubuntu1
 Depends: libc6 (>= 2.8~20080505), libssl0.9.8 (>= 0.9.8f-5)
 Conflicts: wget-ssl
 DPKG_S
-      @provider.stub(:popen4).with("dpkg -s wget").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      allow(@provider).to receive(:popen4).with("dpkg -s wget").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
 
       @provider.load_current_resource
-      @provider.current_resource.version.should == "1.11.4-1ubuntu1"
+      expect(@provider.current_resource.version).to eq("1.11.4-1ubuntu1")
     end
 
     it "should raise an exception if dpkg 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
   end
 
   describe Chef::Provider::Package::Dpkg, "install and upgrade" do
     it "should run dpkg -i with the package source" do
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
       @provider.install_package("wget", "1.11.4-1ubuntu1")
@@ -131,7 +131,7 @@ DPKG_S
     it "should run dpkg -i if the package is a path and the source is nil" do
       @new_resource = Chef::Resource::Package.new("/tmp/wget_1.11.4-1ubuntu1_amd64.deb")
       @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
       @provider.install_package("/tmp/wget_1.11.4-1ubuntu1_amd64.deb", "1.11.4-1ubuntu1")
@@ -140,55 +140,55 @@ DPKG_S
     it "should run dpkg -i if the package is a path and the source is nil for an upgrade" do
       @new_resource = Chef::Resource::Package.new("/tmp/wget_1.11.4-1ubuntu1_amd64.deb")
       @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
       @provider.upgrade_package("/tmp/wget_1.11.4-1ubuntu1_amd64.deb", "1.11.4-1ubuntu1")
     end
 
     it "should run dpkg -i with the package source and options if specified" do
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -i --force-yes /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
-      @new_resource.stub(:options).and_return("--force-yes")
+      allow(@new_resource).to receive(:options).and_return("--force-yes")
 
       @provider.install_package("wget", "1.11.4-1ubuntu1")
     end
     it "should upgrade by running install_package" do
-      @provider.should_receive(:install_package).with("wget", "1.11.4-1ubuntu1")
+      expect(@provider).to receive(:install_package).with("wget", "1.11.4-1ubuntu1")
       @provider.upgrade_package("wget", "1.11.4-1ubuntu1")
     end
   end
 
   describe Chef::Provider::Package::Dpkg, "remove and purge" do
     it "should run dpkg -r to remove the package" do
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -r wget"
       )
       @provider.remove_package("wget", "1.11.4-1ubuntu1")
     end
 
     it "should run dpkg -r to remove the package with options if specified" do
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -r --force-yes wget"
       )
-      @new_resource.stub(:options).and_return("--force-yes")
+      allow(@new_resource).to receive(:options).and_return("--force-yes")
 
       @provider.remove_package("wget", "1.11.4-1ubuntu1")
     end
 
     it "should run dpkg -P to purge the package" do
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -P wget"
       )
       @provider.purge_package("wget", "1.11.4-1ubuntu1")
     end
 
     it "should run dpkg -P to purge the package with options if specified" do
-      @provider.should_receive(:run_noninteractive).with(
+      expect(@provider).to receive(:run_noninteractive).with(
         "dpkg -P --force-yes wget"
       )
-      @new_resource.stub(:options).and_return("--force-yes")
+      allow(@new_resource).to receive(:options).and_return("--force-yes")
 
       @provider.purge_package("wget", "1.11.4-1ubuntu1")
     end

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

@@ -30,79 +30,79 @@ describe Chef::Provider::Package::EasyInstall do
     @current_resource.version('1.8d')
 
     @provider = Chef::Provider::Package::EasyInstall.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 = StringIO.new
     @status = double("Status", :exitstatus => 0)
     @stderr = StringIO.new
     @pid = 2342
-    @provider.stub(:popen4).and_return(@status)
+    allow(@provider).to receive(:popen4).and_return(@status)
   end
 
   describe "easy_install_binary_path" do
     it "should return a Chef::Provider::EasyInstall object" do
       provider = Chef::Provider::Package::EasyInstall.new(@node, @new_resource)
-      provider.should be_a_kind_of(Chef::Provider::Package::EasyInstall)
+      expect(provider).to be_a_kind_of(Chef::Provider::Package::EasyInstall)
     end
 
     it "should set the current resources package name to the new resources package name" do
-      $stdout.stub(:write)
-      @current_resource.should_receive(:package_name).with(@new_resource.package_name)
+      allow($stdout).to receive(:write)
+      expect(@current_resource).to receive(:package_name).with(@new_resource.package_name)
       @provider.load_current_resource
     end
 
     it "should return a relative path to easy_install if no easy_install_binary is given" do
-      @provider.easy_install_binary_path.should eql("easy_install")
+      expect(@provider.easy_install_binary_path).to eql("easy_install")
     end
 
     it "should return a specific path to easy_install if a easy_install_binary is given" do
-      @new_resource.should_receive(:easy_install_binary).and_return("/opt/local/bin/custom/easy_install")
-      @provider.easy_install_binary_path.should eql("/opt/local/bin/custom/easy_install")
+      expect(@new_resource).to receive(:easy_install_binary).and_return("/opt/local/bin/custom/easy_install")
+      expect(@provider.easy_install_binary_path).to eql("/opt/local/bin/custom/easy_install")
     end
 
   end
 
   describe "actions_on_package" do
     it "should run easy_install with the package name and version" do
-      @provider.should_receive(:run_command).with({
+      expect(@provider).to receive(:run_command).with({
         :command => "easy_install \"boto==1.8d\""
       })
       @provider.install_package("boto", "1.8d")
     end
 
     it "should run easy_install with the package name and version and specified options" do
-      @provider.should_receive(:run_command).with({
+      expect(@provider).to receive(:run_command).with({
         :command => "easy_install --always-unzip \"boto==1.8d\""
       })
-      @new_resource.stub(:options).and_return("--always-unzip")
+      allow(@new_resource).to receive(:options).and_return("--always-unzip")
       @provider.install_package("boto", "1.8d")
     end
 
     it "should run easy_install with the package name and version" do
-      @provider.should_receive(:run_command).with({
+      expect(@provider).to receive(:run_command).with({
         :command => "easy_install \"boto==1.8d\""
       })
       @provider.upgrade_package("boto", "1.8d")
     end
 
     it "should run easy_install -m with the package name and version" do
-      @provider.should_receive(:run_command).with({
+      expect(@provider).to receive(:run_command).with({
         :command => "easy_install -m boto"
       })
       @provider.remove_package("boto", "1.8d")
     end
 
     it "should run easy_install -m with the package name and version and specified options" do
-      @provider.should_receive(:run_command).with({
+      expect(@provider).to receive(:run_command).with({
         :command => "easy_install -x -m boto"
       })
-      @new_resource.stub(:options).and_return("-x")
+      allow(@new_resource).to receive(:options).and_return("-x")
       @provider.remove_package("boto", "1.8d")
     end
 
     it "should run easy_install -m with the package name and version" do
-      @provider.should_receive(:run_command).with({
+      expect(@provider).to receive(:run_command).with({
         :command => "easy_install -m boto"
       })
       @provider.purge_package("boto", "1.8d")

data/spec/unit/provider/package/freebsd/pkg_spec.rb

@@ -30,35 +30,35 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
 
     @provider = Chef::Provider::Package::Freebsd::Pkg.new(@new_resource, @run_context)
     @provider.current_resource = @current_resource
-    ::File.stub(:exist?).with('/usr/ports/Makefile').and_return(false)
+    allow(::File).to receive(:exist?).with('/usr/ports/Makefile').and_return(false)
   end
 
   describe "when determining the current package state" do
     before do
-      @provider.stub(:ports_candidate_version).and_return("4.3.6")
+      allow(@provider).to receive(:ports_candidate_version).and_return("4.3.6")
     end
 
     it "should create a current resource with the name of the new_resource" do
       current_resource = Chef::Provider::Package::Freebsd::Pkg.new(@new_resource, @run_context).current_resource
-      current_resource.name.should == "zsh"
+      expect(current_resource.name).to eq("zsh")
     end
 
     it "should return a version if the package is installed" do
-      @provider.should_receive(:current_installed_version).and_return("4.3.6_7")
+      expect(@provider).to receive(:current_installed_version).and_return("4.3.6_7")
       @provider.load_current_resource
-      @current_resource.version.should == "4.3.6_7"
+      expect(@current_resource.version).to eq("4.3.6_7")
     end
 
     it "should return nil if the package is not installed" do
-      @provider.should_receive(:current_installed_version).and_return(nil)
+      expect(@provider).to receive(:current_installed_version).and_return(nil)
       @provider.load_current_resource
-      @current_resource.version.should be_nil
+      expect(@current_resource.version).to be_nil
     end
 
     it "should return a candidate version if it exists" do
-      @provider.should_receive(:current_installed_version).and_return(nil)
+      expect(@provider).to receive(:current_installed_version).and_return(nil)
       @provider.load_current_resource
-      @provider.candidate_version.should eql("4.3.6")
+      expect(@provider.candidate_version).to eql("4.3.6")
     end
   end
 
@@ -77,42 +77,42 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
 
     it "should return the version number when it is installed" do
       pkg_info = OpenStruct.new(:stdout => "zsh-4.3.6_7")
-      @provider.should_receive(:shell_out!).with('pkg_info -E "zsh*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
+      expect(@provider).to receive(:shell_out!).with('pkg_info -E "zsh*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
       #@provider.should_receive(:popen4).with('pkg_info -E "zsh*"').and_yield(@pid, @stdin, ["zsh-4.3.6_7"], @stderr).and_return(@status)
-      @provider.stub(:package_name).and_return("zsh")
-      @provider.current_installed_version.should == "4.3.6_7"
+      allow(@provider).to receive(:package_name).and_return("zsh")
+      expect(@provider.current_installed_version).to eq("4.3.6_7")
     end
 
     it "does not set the current version number when the package is not installed" do
       pkg_info = OpenStruct.new(:stdout => "")
-      @provider.should_receive(:shell_out!).with('pkg_info -E "zsh*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
-      @provider.stub(:package_name).and_return("zsh")
-      @provider.current_installed_version.should be_nil
+      expect(@provider).to receive(:shell_out!).with('pkg_info -E "zsh*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
+      allow(@provider).to receive(:package_name).and_return("zsh")
+      expect(@provider.current_installed_version).to be_nil
     end
 
     it "should return the port path for a valid port name" do
       whereis = OpenStruct.new(:stdout => "zsh: /usr/ports/shells/zsh")
-      @provider.should_receive(:shell_out!).with("whereis -s zsh", :env => nil).and_return(whereis)
+      expect(@provider).to receive(:shell_out!).with("whereis -s zsh", :env => nil).and_return(whereis)
       #@provider.should_receive(:popen4).with("whereis -s zsh").and_yield(@pid, @stdin, ["zsh: /usr/ports/shells/zsh"], @stderr).and_return(@status)
-      @provider.stub(:port_name).and_return("zsh")
-      @provider.port_path.should == "/usr/ports/shells/zsh"
+      allow(@provider).to receive(:port_name).and_return("zsh")
+      expect(@provider.port_path).to eq("/usr/ports/shells/zsh")
     end
 
     # Not happy with the form of these tests as they are far too closely tied to the implementation and so very fragile.
     it "should return the ports candidate version when given a valid port path" do
-      @provider.stub(:port_path).and_return("/usr/ports/shells/zsh")
+      allow(@provider).to receive(:port_path).and_return("/usr/ports/shells/zsh")
       make_v = OpenStruct.new(:stdout => "4.3.6\n", :exitstatus => 0)
-      @provider.should_receive(:shell_out!).with("make -V PORTVERSION", {:cwd=>"/usr/ports/shells/zsh", :returns=>[0, 1], :env=>nil}).and_return(make_v)
-      @provider.ports_candidate_version.should == "4.3.6"
+      expect(@provider).to receive(:shell_out!).with("make -V PORTVERSION", {:cwd=>"/usr/ports/shells/zsh", :returns=>[0, 1], :env=>nil}).and_return(make_v)
+      expect(@provider.ports_candidate_version).to eq("4.3.6")
     end
 
     it "should figure out the package name when we have ports" do
-      ::File.stub(:exist?).with('/usr/ports/Makefile').and_return(true)
-      @provider.stub(:port_path).and_return("/usr/ports/shells/zsh")
+      allow(::File).to receive(:exist?).with('/usr/ports/Makefile').and_return(true)
+      allow(@provider).to receive(:port_path).and_return("/usr/ports/shells/zsh")
       make_v = OpenStruct.new(:stdout => "zsh-4.3.6_7\n", :exitstatus => 0)
-      @provider.should_receive(:shell_out!).with("make -V PKGNAME", {:cwd=>"/usr/ports/shells/zsh", :env=>nil, :returns=>[0, 1]}).and_return(make_v)
+      expect(@provider).to receive(:shell_out!).with("make -V PKGNAME", {:cwd=>"/usr/ports/shells/zsh", :env=>nil, :returns=>[0, 1]}).and_return(make_v)
       #@provider.should_receive(:ports_makefile_variable_value).with("PKGNAME").and_return("zsh-4.3.6_7")
-      @provider.package_name.should == "zsh"
+      expect(@provider.package_name).to eq("zsh")
     end
   end
 
@@ -121,13 +121,13 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
       @cmd_result = OpenStruct.new(:status => true)
 
       @provider.current_resource = @current_resource
-      @provider.stub(:package_name).and_return("zsh")
-      @provider.stub(:latest_link_name).and_return("zsh")
-      @provider.stub(:port_path).and_return("/usr/ports/shells/zsh")
+      allow(@provider).to receive(:package_name).and_return("zsh")
+      allow(@provider).to receive(:latest_link_name).and_return("zsh")
+      allow(@provider).to receive(:port_path).and_return("/usr/ports/shells/zsh")
     end
 
     it "should run pkg_add -r with the package name" do
-      @provider.should_receive(:shell_out!).with("pkg_add -r zsh", :env => nil).and_return(@cmd_result)
+      expect(@provider).to receive(:shell_out!).with("pkg_add -r zsh", :env => nil).and_return(@cmd_result)
       @provider.install_package("zsh", "4.3.6_7")
     end
   end
@@ -142,15 +142,15 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
 
     it "should figure out the port path from the package_name using whereis" do
       whereis = OpenStruct.new(:stdout => "zsh: /usr/ports/shells/zsh")
-      @provider.should_receive(:shell_out!).with("whereis -s zsh", :env=>nil).and_return(whereis)
-      @provider.port_path.should == "/usr/ports/shells/zsh"
+      expect(@provider).to receive(:shell_out!).with("whereis -s zsh", :env=>nil).and_return(whereis)
+      expect(@provider.port_path).to eq("/usr/ports/shells/zsh")
     end
 
     it "should use the package_name as the port path when it starts with /" do
       new_resource = Chef::Resource::Package.new("/usr/ports/www/wordpress")
       provider = Chef::Provider::Package::Freebsd::Pkg.new(new_resource, @run_context)
-      provider.should_not_receive(:popen4)
-      provider.port_path.should == "/usr/ports/www/wordpress"
+      expect(provider).not_to receive(:popen4)
+      expect(provider.port_path).to eq("/usr/ports/www/wordpress")
     end
 
     it "should use the package_name as a relative path from /usr/ports when it contains / but doesn't start with it" do
@@ -159,8 +159,8 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
       #                       :cookbook_name => "xenoparadox")
       new_resource = Chef::Resource::Package.new("www/wordpress")
       provider = Chef::Provider::Package::Freebsd::Pkg.new(new_resource, @run_context)
-      provider.should_not_receive(:popen4)
-      provider.port_path.should == "/usr/ports/www/wordpress"
+      expect(provider).not_to receive(:popen4)
+      expect(provider.port_path).to eq("/usr/ports/www/wordpress")
     end
   end
 
@@ -170,15 +170,15 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
       @current_resource = Chef::Resource::Package.new("ruby-iconv")
       @provider = Chef::Provider::Package::Freebsd::Pkg.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      @provider.stub(:port_path).and_return("/usr/ports/converters/ruby-iconv")
-      @provider.stub(:package_name).and_return("ruby18-iconv")
-      @provider.stub(:latest_link_name).and_return("ruby18-iconv")
+      allow(@provider).to receive(:port_path).and_return("/usr/ports/converters/ruby-iconv")
+      allow(@provider).to receive(:package_name).and_return("ruby18-iconv")
+      allow(@provider).to receive(:latest_link_name).and_return("ruby18-iconv")
 
       @install_result = OpenStruct.new(:status => true)
     end
 
     it "should run pkg_add -r with the package name" do
-      @provider.should_receive(:shell_out!).with("pkg_add -r ruby18-iconv", :env => nil).and_return(@install_result)
+      expect(@provider).to receive(:shell_out!).with("pkg_add -r ruby18-iconv", :env => nil).and_return(@install_result)
       @provider.install_package("ruby-iconv", "1.0")
     end
   end
@@ -189,11 +189,11 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
       @new_resource.version "4.3.6_7"
       @current_resource.version "4.3.6_7"
       @provider.current_resource = @current_resource
-      @provider.stub(:package_name).and_return("zsh")
+      allow(@provider).to receive(:package_name).and_return("zsh")
     end
 
     it "should run pkg_delete with the package name and version" do
-      @provider.should_receive(:shell_out!).with("pkg_delete zsh-4.3.6_7", :env => nil).and_return(@pkg_delete)
+      expect(@provider).to receive(:shell_out!).with("pkg_delete zsh-4.3.6_7", :env => nil).and_return(@pkg_delete)
       @provider.remove_package("zsh", "4.3.6_7")
     end
   end
@@ -213,16 +213,16 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
 
     it "should return the port path for a valid port name" do
       whereis = OpenStruct.new(:stdout => "bonnie++: /usr/ports/benchmarks/bonnie++")
-      @provider.should_receive(:shell_out!).with("whereis -s bonnie++", :env => nil).and_return(whereis)
-      @provider.stub(:port_name).and_return("bonnie++")
-      @provider.port_path.should == "/usr/ports/benchmarks/bonnie++"
+      expect(@provider).to receive(:shell_out!).with("whereis -s bonnie++", :env => nil).and_return(whereis)
+      allow(@provider).to receive(:port_name).and_return("bonnie++")
+      expect(@provider.port_path).to eq("/usr/ports/benchmarks/bonnie++")
     end
 
     it "should return the version number when it is installed" do
       pkg_info = OpenStruct.new(:stdout => "bonnie++-1.96")
-      @provider.should_receive(:shell_out!).with('pkg_info -E "bonnie++*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
-      @provider.stub(:package_name).and_return("bonnie++")
-      @provider.current_installed_version.should == "1.96"
+      expect(@provider).to receive(:shell_out!).with('pkg_info -E "bonnie++*"', :env => nil, :returns => [0,1]).and_return(pkg_info)
+      allow(@provider).to receive(:package_name).and_return("bonnie++")
+      expect(@provider.current_installed_version).to eq("1.96")
     end
   end
 
@@ -249,11 +249,11 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
       @current_resource = Chef::Resource::Package.new("perl5.8")
       @provider = Chef::Provider::Package::Freebsd::Pkg.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      @provider.stub(:package_name).and_return("perl")
-      @provider.stub(:latest_link_name).and_return("perl")
+      allow(@provider).to receive(:package_name).and_return("perl")
+      allow(@provider).to receive(:latest_link_name).and_return("perl")
 
       cmd = OpenStruct.new(:status => true)
-      @provider.should_receive(:shell_out!).with("pkg_add -r perl", :env => nil).and_return(cmd)
+      expect(@provider).to receive(:shell_out!).with("pkg_add -r perl", :env => nil).and_return(cmd)
       @provider.install_package("perl5.8", "5.8.8_1")
     end
 
@@ -263,11 +263,11 @@ describe Chef::Provider::Package::Freebsd::Pkg, "load_current_resource" do
       @current_resource = Chef::Resource::Package.new("mysql50-server")
       @provider = Chef::Provider::Package::Freebsd::Pkg.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      @provider.stub(:package_name).and_return("mysql-server")
-      @provider.stub(:latest_link_name).and_return("mysql50-server")
+      allow(@provider).to receive(:package_name).and_return("mysql-server")
+      allow(@provider).to receive(:latest_link_name).and_return("mysql50-server")
 
       cmd = OpenStruct.new(:status => true)
-      @provider.should_receive(:shell_out!).with("pkg_add -r mysql50-server", :env=>nil).and_return(cmd)
+      expect(@provider).to receive(:shell_out!).with("pkg_add -r mysql50-server", :env=>nil).and_return(cmd)
       @provider.install_package("mysql50-server", "5.0.45_1")
     end
   end