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

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

@@ -40,12 +40,12 @@ describe Chef::Provider::Mount::Windows do
     @new_resource = Chef::Resource::Mount.new("X:")
     @new_resource.device GUID
     @current_resource = Chef::Resource::Mount.new("X:")
-    Chef::Resource::Mount.stub(:new).and_return(@current_resource)
+    allow(Chef::Resource::Mount).to receive(:new).and_return(@current_resource)
 
     @net_use = double("Chef::Util::Windows::NetUse")
-    Chef::Util::Windows::NetUse.stub(:new).and_return(@net_use)
+    allow(Chef::Util::Windows::NetUse).to receive(:new).and_return(@net_use)
     @vol = double("Chef::Util::Windows::Volume")
-    Chef::Util::Windows::Volume.stub(:new).and_return(@vol)
+    allow(Chef::Util::Windows::Volume).to receive(:new).and_return(@vol)
 
     @provider = Chef::Provider::Mount::Windows.new(@new_resource, @run_context)
     @provider.current_resource = @current_resource
@@ -53,26 +53,26 @@ describe Chef::Provider::Mount::Windows do
 
   describe "when loading the current resource" do
     it "should set mounted true if the mount point is found" do
-      @vol.stub(:device).and_return(@new_resource.device)
-      @current_resource.should_receive(:mounted).with(true)
+      allow(@vol).to receive(:device).and_return(@new_resource.device)
+      expect(@current_resource).to receive(:mounted).with(true)
       @provider.load_current_resource
     end
 
     it "should set mounted false if the mount point is not found" do
-      @vol.stub(:device).and_raise(ArgumentError)
-      @current_resource.should_receive(:mounted).with(false)
+      allow(@vol).to receive(:device).and_raise(ArgumentError)
+      expect(@current_resource).to receive(:mounted).with(false)
       @provider.load_current_resource
     end
 
     describe "with a local device" do
       before do
         @new_resource.device GUID
-        @vol.stub(:device).and_return(@new_resource.device)
-        @net_use.stub(:device).and_raise(ArgumentError)
+        allow(@vol).to receive(:device).and_return(@new_resource.device)
+        allow(@net_use).to receive(:device).and_raise(ArgumentError)
       end
 
       it "should determine the device is a volume GUID" do
-        @provider.should_receive(:is_volume).with(@new_resource.device).and_return(true)
+        expect(@provider).to receive(:is_volume).with(@new_resource.device).and_return(true)
         @provider.load_current_resource
       end
     end
@@ -80,12 +80,12 @@ describe Chef::Provider::Mount::Windows do
     describe "with a remote device" do
       before do
         @new_resource.device REMOTE
-        @net_use.stub(:device).and_return(@new_resource.device)
-        @vol.stub(:device).and_raise(ArgumentError)
+        allow(@net_use).to receive(:device).and_return(@new_resource.device)
+        allow(@vol).to receive(:device).and_raise(ArgumentError)
       end
 
       it "should determine the device is remote" do
-        @provider.should_receive(:is_volume).with(@new_resource.device).and_return(false)
+        expect(@provider).to receive(:is_volume).with(@new_resource.device).and_return(false)
         @provider.load_current_resource
       end
     end
@@ -93,13 +93,13 @@ describe Chef::Provider::Mount::Windows do
     describe "when mounting a file system" do
       before do
         @new_resource.device GUID
-        @vol.stub(:add)
-        @vol.stub(:device).and_raise(ArgumentError)
+        allow(@vol).to receive(:add)
+        allow(@vol).to receive(:device).and_raise(ArgumentError)
         @provider.load_current_resource
       end
 
       it "should mount the filesystem if it is not mounted" do
-        @vol.should_receive(:add).with(:remote => @new_resource.device,
+        expect(@vol).to receive(:add).with(:remote => @new_resource.device,
                                        :username => @new_resource.username,
                                        :domainname => @new_resource.domain,
                                        :password => @new_resource.password)
@@ -107,8 +107,8 @@ describe Chef::Provider::Mount::Windows do
       end
 
       it "should not mount the filesystem if it is mounted" do
-        @vol.should_not_receive(:add)
-        @current_resource.stub(:mounted).and_return(true)
+        expect(@vol).not_to receive(:add)
+        allow(@current_resource).to receive(:mounted).and_return(true)
         @provider.mount_fs
       end
     end
@@ -116,20 +116,20 @@ describe Chef::Provider::Mount::Windows do
     describe "when unmounting a file system" do
       before do
         @new_resource.device GUID
-        @vol.stub(:delete)
-        @vol.stub(:device).and_raise(ArgumentError)
+        allow(@vol).to receive(:delete)
+        allow(@vol).to receive(:device).and_raise(ArgumentError)
         @provider.load_current_resource
       end
 
       it "should umount the filesystem if it is mounted" do
-        @current_resource.stub(:mounted).and_return(true)
-        @vol.should_receive(:delete)
+        allow(@current_resource).to receive(:mounted).and_return(true)
+        expect(@vol).to receive(:delete)
         @provider.umount_fs
       end
 
       it "should not umount the filesystem if it is not mounted" do
-        @current_resource.stub(:mounted).and_return(false)
-        @vol.should_not_receive(:delete)
+        allow(@current_resource).to receive(:mounted).and_return(false)
+        expect(@vol).not_to receive(:delete)
         @provider.umount_fs
       end
     end

data/spec/unit/provider/ohai_spec.rb

@@ -41,16 +41,16 @@ describe Chef::Provider::Ohai do
         :newdata => "somevalue"
       }
     }
-    mock_ohai.stub(:all_plugins).and_return(true)
-    mock_ohai.stub(:data).and_return(mock_ohai[:data],
+    allow(mock_ohai).to receive(:all_plugins).and_return(true)
+    allow(mock_ohai).to receive(:data).and_return(mock_ohai[:data],
                                       mock_ohai[:data2])
-    Ohai::System.stub(:new).and_return(mock_ohai)
-    Chef::Platform.stub(:find_platform_and_version).and_return({ "platform" => @platform,
+    allow(Ohai::System).to receive(:new).and_return(mock_ohai)
+    allow(Chef::Platform).to receive(:find_platform_and_version).and_return({ "platform" => @platform,
                                                                   "platform_version" => @platform_version})
     # Fake node with a dummy save
     @node = Chef::Node.new
     @node.name(@fqdn)
-    @node.stub(:save).and_return(@node)
+    allow(@node).to receive(:save).and_return(@node)
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
     @new_resource = Chef::Resource::Ohai.new("ohai_reload")
@@ -67,18 +67,18 @@ describe Chef::Provider::Ohai do
     end
 
     it "applies updated ohai data to the node" do
-      @node[:origdata].should == 'somevalue'
-      @node[:newdata].should be_nil
+      expect(@node[:origdata]).to eq('somevalue')
+      expect(@node[:newdata]).to be_nil
       @provider.run_action(:reload)
-      @node[:origdata].should == 'somevalue'
-      @node[:newdata].should == 'somevalue'
+      expect(@node[:origdata]).to eq('somevalue')
+      expect(@node[:newdata]).to eq('somevalue')
     end
 
     it "should reload a specific plugin and cause node to pick up new values" do
       @new_resource.plugin "someplugin"
       @provider.run_action(:reload)
-      @node[:origdata].should == 'somevalue'
-      @node[:newdata].should == 'somevalue'
+      expect(@node[:origdata]).to eq('somevalue')
+      expect(@node[:newdata]).to eq('somevalue')
     end
   end
 end

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

@@ -28,7 +28,7 @@ describe Chef::Provider::Package::Aix do
     @new_resource.source("/tmp/samba.base")
 
     @provider = Chef::Provider::Package::Aix.new(@new_resource, @run_context)
-    ::File.stub(:exists?).and_return(true)
+    allow(::File).to receive(:exists?).and_return(true)
   end
 
   describe "assessing the current package status" do
@@ -40,118 +40,118 @@ describe Chef::Provider::Package::Aix do
     end
 
     it "should create a current resource with the name of new_resource" do
-      @provider.stub(:popen4).and_return(@status)
+      allow(@provider).to receive(:popen4).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.name.should == "samba.base"
+      expect(@provider.current_resource.name).to eq("samba.base")
     end
 
     it "should set the current resource bff package name to the new resource bff 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 == "samba.base"
+      expect(@provider.current_resource.package_name).to eq("samba.base")
     end
 
     it "should raise an exception if a source is supplied but not found" do
-      @provider.stub(:popen4).and_return(@status)
-      ::File.stub(:exists?).and_return(false)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      allow(::File).to receive(:exists?).and_return(false)
       @provider.define_resource_requirements
       @provider.load_current_resource
-      lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Package)
+      expect { @provider.process_resource_requirements }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should get the source package version from lslpp if provided" do
       @stdout = StringIO.new(@bffinfo)
       @stdin, @stderr = StringIO.new, StringIO.new
-      @provider.should_receive(:popen4).with("installp -L -d /tmp/samba.base").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.should_receive(:popen4).with("lslpp -lcq samba.base").and_return(@status)
+      expect(@provider).to receive(:popen4).with("installp -L -d /tmp/samba.base").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("lslpp -lcq samba.base").and_return(@status)
       @provider.load_current_resource
 
-      @provider.current_resource.package_name.should == "samba.base"
-      @new_resource.version.should == "3.3.12.0"
+      expect(@provider.current_resource.package_name).to eq("samba.base")
+      expect(@new_resource.version).to eq("3.3.12.0")
     end
 
     it "should return the current version installed if found by lslpp" do
       @stdout = StringIO.new(@bffinfo)
       @stdin, @stderr = StringIO.new, StringIO.new
-      @provider.should_receive(:popen4).with("installp -L -d /tmp/samba.base").and_return(@status)
-      @provider.should_receive(:popen4).with("lslpp -lcq samba.base").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("installp -L -d /tmp/samba.base").and_return(@status)
+      expect(@provider).to receive(:popen4).with("lslpp -lcq samba.base").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should == "3.3.12.0"
+      expect(@provider.current_resource.version).to eq("3.3.12.0")
     end
 
     it "should raise an exception if the source is not set but we are installing" do
       @new_resource = Chef::Resource::Package.new("samba.base")
       @provider = Chef::Provider::Package::Aix.new(@new_resource, @run_context)
-      @provider.stub(:popen4).and_return(@status)
-      lambda { @provider.run_action(:install) }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should raise an exception if installp/lslpp fails to run" do
       @status = double("Status", :exitstatus => -1)
-      @provider.stub(:popen4).and_return(@status)
-      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should return a current resource with a nil version if the package is not found" do
       @stdout = StringIO.new
-      @provider.should_receive(:popen4).with("installp -L -d /tmp/samba.base").and_return(@status)
-      @provider.should_receive(:popen4).with("lslpp -lcq samba.base").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("installp -L -d /tmp/samba.base").and_return(@status)
+      expect(@provider).to receive(:popen4).with("lslpp -lcq samba.base").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should be_nil
+      expect(@provider.current_resource.version).to be_nil
     end
   end
 
   describe "candidate_version" do
     it "should return the candidate_version variable if already setup" do
       @provider.candidate_version = "3.3.12.0"
-      @provider.should_not_receive(:popen4)
+      expect(@provider).not_to receive(:popen4)
       @provider.candidate_version
     end
 
     it "should lookup the candidate_version if the variable is not already set" do
       @status = double("Status", :exitstatus => 0)
-      @provider.should_receive(:popen4).and_return(@status)
+      expect(@provider).to receive(:popen4).and_return(@status)
       @provider.candidate_version
     end
 
     it "should throw and exception if the exitstatus is not 0" do
       @status = double("Status", :exitstatus => 1)
-      @provider.stub(:popen4).and_return(@status)
-      lambda { @provider.candidate_version }.should raise_error(Chef::Exceptions::Package)
+      allow(@provider).to receive(:popen4).and_return(@status)
+      expect { @provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
     end
 
   end
 
   describe "install and upgrade" do
     it "should run installp -aYF -d with the package source to install" do
-      @provider.should_receive(:shell_out!).with("installp -aYF -d /tmp/samba.base samba.base")
+      expect(@provider).to receive(:shell_out!).with("installp -aYF -d /tmp/samba.base samba.base")
       @provider.install_package("samba.base", "3.3.12.0")
     end
 
     it "should run  when the package is a path to install" do
       @new_resource = Chef::Resource::Package.new("/tmp/samba.base")
       @provider = Chef::Provider::Package::Aix.new(@new_resource, @run_context)
-      @new_resource.source.should == "/tmp/samba.base"
-      @provider.should_receive(:shell_out!).with("installp -aYF -d /tmp/samba.base /tmp/samba.base")
+      expect(@new_resource.source).to eq("/tmp/samba.base")
+      expect(@provider).to receive(:shell_out!).with("installp -aYF -d /tmp/samba.base /tmp/samba.base")
       @provider.install_package("/tmp/samba.base", "3.3.12.0")
     end
 
     it "should run installp with -eLogfile option." do
-      @new_resource.stub(:options).and_return("-e/tmp/installp.log")
-      @provider.should_receive(:shell_out!).with("installp -aYF  -e/tmp/installp.log -d /tmp/samba.base samba.base")
+      allow(@new_resource).to receive(:options).and_return("-e/tmp/installp.log")
+      expect(@provider).to receive(:shell_out!).with("installp -aYF  -e/tmp/installp.log -d /tmp/samba.base samba.base")
       @provider.install_package("samba.base", "3.3.12.0")
     end
   end
 
   describe "remove" do
     it "should run installp -u samba.base to remove the package" do
-      @provider.should_receive(:shell_out!).with("installp -u samba.base")
+      expect(@provider).to receive(:shell_out!).with("installp -u samba.base")
       @provider.remove_package("samba.base", "3.3.12.0")
     end
 
     it "should run installp -u -e/tmp/installp.log  with options -e/tmp/installp.log" do
-      @new_resource.stub(:options).and_return("-e/tmp/installp.log")
-      @provider.should_receive(:shell_out!).with("installp -u  -e/tmp/installp.log samba.base")
+      allow(@new_resource).to receive(:options).and_return("-e/tmp/installp.log")
+      expect(@provider).to receive(:shell_out!).with("installp -u  -e/tmp/installp.log samba.base")
       @provider.remove_package("samba.base", "3.3.12.0")
     end
 

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

@@ -45,17 +45,17 @@ PKG_STATUS
   describe "when loading current resource" do
 
     it "should create a current resource with the name of the new_resource" do
-      @provider.should_receive(:shell_out!).with(
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache policy #{@new_resource.package_name}",
         :timeout => @timeout
       ).and_return(@shell_out)
       @provider.load_current_resource
 
       current_resource = @provider.current_resource
-      current_resource.should be_a(Chef::Resource::Package)
-      current_resource.name.should == "irssi"
-      current_resource.package_name.should == "irssi"
-      current_resource.version.should be_nil
+      expect(current_resource).to be_a(Chef::Resource::Package)
+      expect(current_resource.name).to eq("irssi")
+      expect(current_resource.package_name).to eq("irssi")
+      expect(current_resource.version).to be_nil
     end
 
     it "should set the installed version if package has one" do
@@ -71,10 +71,10 @@ sudo:
      1.7.2p1-1ubuntu5 0
         500 http://us.archive.ubuntu.com/ubuntu/ lucid/main Packages
 INSTALLED
-      @provider.should_receive(:shell_out!).and_return(@shell_out)
+      expect(@provider).to receive(:shell_out!).and_return(@shell_out)
       @provider.load_current_resource
-      @provider.current_resource.version.should == "1.7.2p1-1ubuntu5.3"
-      @provider.candidate_version.should eql("1.7.2p1-1ubuntu5.3")
+      expect(@provider.current_resource.version).to eq("1.7.2p1-1ubuntu5.3")
+      expect(@provider.candidate_version).to eql("1.7.2p1-1ubuntu5.3")
     end
 
     # libmysqlclient-dev is a real package in newer versions of debian + ubuntu
@@ -88,7 +88,7 @@ libmysqlclient15-dev:
   Version table:
 VPKG_STDOUT
       virtual_package = double(:stdout => virtual_package_out,:exitstatus => 0)
-      @provider.should_receive(:shell_out!).with(
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache policy libmysqlclient15-dev",
         :timeout => @timeout
       ).and_return(virtual_package)
@@ -111,7 +111,7 @@ libmysqlclient-dev 5.1.41-3ubuntu12.10
 libmysqlclient-dev 5.1.41-3ubuntu12
 SHOWPKG_STDOUT
       showpkg = double(:stdout => showpkg_out,:exitstatus => 0)
-      @provider.should_receive(:shell_out!).with(
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache showpkg libmysqlclient15-dev",
         :timeout => @timeout
       ).and_return(showpkg)
@@ -129,7 +129,7 @@ libmysqlclient-dev:
         500 http://us.archive.ubuntu.com/ubuntu/ lucid/main Packages
 RPKG_STDOUT
       real_package = double(:stdout => real_package_out,:exitstatus => 0)
-      @provider.should_receive(:shell_out!).with(
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache policy libmysqlclient-dev",
         :timeout => @timeout
       ).and_return(real_package)
@@ -145,7 +145,7 @@ mp3-decoder:
   Version table:
 VPKG_STDOUT
       virtual_package = double(:stdout => virtual_package_out,:exitstatus => 0)
-      @provider.should_receive(:shell_out!).with(
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache policy mp3-decoder",
         :timeout => @timeout
       ).and_return(virtual_package)
@@ -171,20 +171,20 @@ mpg321 0.2.10.6
 mpg123 1.12.1-0ubuntu1
 SHOWPKG_STDOUT
       showpkg = double(:stdout => showpkg_out,:exitstatus => 0)
-      @provider.should_receive(:shell_out!).with(
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache showpkg mp3-decoder",
         :timeout => @timeout
       ).and_return(showpkg)
-      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 run apt-cache policy with the default_release option, if there is one and provider is explicitly defined" do
       @new_resource = Chef::Resource::AptPackage.new("irssi", @run_context)
       @provider = Chef::Provider::Package::Apt.new(@new_resource, @run_context)
 
-      @new_resource.stub(:default_release).and_return("lenny-backports")
-      @new_resource.stub(:provider).and_return("Chef::Provider::Package::Apt")
-      @provider.should_receive(:shell_out!).with(
+      allow(@new_resource).to receive(:default_release).and_return("lenny-backports")
+      allow(@new_resource).to receive(:provider).and_return("Chef::Provider::Package::Apt")
+      expect(@provider).to receive(:shell_out!).with(
         "apt-cache -o APT::Default-Release=lenny-backports policy irssi",
         :timeout => @timeout
       ).and_return(@shell_out)
@@ -194,7 +194,7 @@ SHOWPKG_STDOUT
     it "raises an exception if a source is specified (CHEF-5113)" do
       @new_resource.source "pluto"
       @provider.define_resource_requirements
-      @provider.should_receive(:shell_out!).with("apt-cache policy irssi", {:timeout=>900}).and_return(@shell_out)
+      expect(@provider).to receive(:shell_out!).with("apt-cache policy irssi", {:timeout=>900}).and_return(@shell_out)
       expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
   end
@@ -207,7 +207,7 @@ SHOWPKG_STDOUT
 
     describe "install_package" do
       it "should run apt-get install with the package name and version" do
-        @provider.should_receive(:shell_out!). with(
+        expect(@provider).to receive(:shell_out!). with(
           "apt-get -q -y install irssi=0.8.12-7",
           :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil},
           :timeout => @timeout
@@ -216,7 +216,7 @@ SHOWPKG_STDOUT
       end
 
       it "should run apt-get install with the package name and version and options if specified" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "apt-get -q -y --force-yes install irssi=0.8.12-7",
           :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
           :timeout => @timeout
@@ -229,10 +229,10 @@ SHOWPKG_STDOUT
         @new_resource = nil
         @new_resource = Chef::Resource::AptPackage.new("irssi", @run_context)
         @new_resource.default_release("lenny-backports")
-
+        @new_resource.provider = @provider
         @provider.new_resource = @new_resource
 
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "apt-get -q -y -o APT::Default-Release=lenny-backports install irssi=0.8.12-7",
           :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
           :timeout => @timeout
@@ -245,7 +245,7 @@ SHOWPKG_STDOUT
     describe Chef::Provider::Package::Apt, "upgrade_package" do
 
       it "should run install_package with the name and version" do
-        @provider.should_receive(:install_package).with("irssi", "0.8.12-7")
+        expect(@provider).to receive(:install_package).with("irssi", "0.8.12-7")
         @provider.upgrade_package("irssi", "0.8.12-7")
       end
     end
@@ -253,7 +253,7 @@ SHOWPKG_STDOUT
     describe Chef::Provider::Package::Apt, "remove_package" do
 
       it "should run apt-get remove with the package name" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "apt-get -q -y remove irssi",
           :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil},
           :timeout => @timeout
@@ -262,7 +262,7 @@ SHOWPKG_STDOUT
       end
 
       it "should run apt-get remove with the package name and options if specified" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "apt-get -q -y --force-yes remove irssi",
           :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
           :timeout => @timeout
@@ -276,7 +276,7 @@ SHOWPKG_STDOUT
     describe "when purging a package" do
 
       it "should run apt-get purge with the package name" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "apt-get -q -y purge irssi",
           :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
           :timeout => @timeout
@@ -285,7 +285,7 @@ SHOWPKG_STDOUT
       end
 
       it "should run apt-get purge with the package name and options if specified" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "apt-get -q -y --force-yes purge irssi",
           :env => { "DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
           :timeout => @timeout
@@ -298,14 +298,14 @@ SHOWPKG_STDOUT
 
     describe "when preseeding a package" do
       before(:each) do
-        @provider.stub(:get_preseed_file).and_return("/tmp/irssi-0.8.12-7.seed")
+        allow(@provider).to receive(:get_preseed_file).and_return("/tmp/irssi-0.8.12-7.seed")
       end
 
       it "should get the full path to the preseed response file" do
-        @provider.should_receive(:get_preseed_file).with("irssi", "0.8.12-7").and_return("/tmp/irssi-0.8.12-7.seed")
+        expect(@provider).to receive(:get_preseed_file).with("irssi", "0.8.12-7").and_return("/tmp/irssi-0.8.12-7.seed")
         file = @provider.get_preseed_file("irssi", "0.8.12-7")
 
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "debconf-set-selections /tmp/irssi-0.8.12-7.seed",
           :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil},
           :timeout => @timeout
@@ -315,7 +315,7 @@ SHOWPKG_STDOUT
       end
 
       it "should run debconf-set-selections on the preseed file if it has changed" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "debconf-set-selections /tmp/irssi-0.8.12-7.seed",
           :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil},
           :timeout => @timeout
@@ -325,18 +325,18 @@ SHOWPKG_STDOUT
       end
 
       it "should not run debconf-set-selections if the preseed file has not changed" do
-        @provider.stub(:check_package_state)
+        allow(@provider).to receive(:check_package_state)
         @current_resource.version "0.8.11"
         @new_resource.response_file "/tmp/file"
-        @provider.stub(:get_preseed_file).and_return(false)
-        @provider.should_not_receive(:shell_out!)
+        allow(@provider).to receive(:get_preseed_file).and_return(false)
+        expect(@provider).not_to receive(:shell_out!)
         @provider.run_action(:reconfig)
       end
     end
 
     describe "when reconfiguring a package" do
       it "should run dpkg-reconfigure package" do
-        @provider.should_receive(:shell_out!).with(
+        expect(@provider).to receive(:shell_out!).with(
           "dpkg-reconfigure irssi",
           :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
           :timeout => @timeout
@@ -348,7 +348,7 @@ SHOWPKG_STDOUT
     describe "when installing a virtual package" do
       it "should install the package without specifying a version" do
           @provider.is_virtual_package = true
-          @provider.should_receive(:shell_out!).with(
+          expect(@provider).to receive(:shell_out!).with(
             "apt-get -q -y install libmysqlclient-dev",
             :env => {"DEBIAN_FRONTEND" => "noninteractive", "LC_ALL" => nil },
             :timeout => @timeout