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

data/spec/unit/provider/link_spec.rb

@@ -45,36 +45,36 @@ describe Chef::Resource::Link, :not_supported_on_win2k3 do
   describe "when the target is a symlink" do
     before(:each) do
       lstat = double("stats", :ino => 5)
-      lstat.stub(:uid).and_return(501)
-      lstat.stub(:gid).and_return(501)
-      lstat.stub(:mode).and_return(0777)
-      File.stub(:lstat).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(lstat)
-      provider.file_class.stub(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
-      provider.file_class.stub(:readlink).with("#{CHEF_SPEC_DATA}/fofile-link").and_return("#{CHEF_SPEC_DATA}/fofile")
+      allow(lstat).to receive(:uid).and_return(501)
+      allow(lstat).to receive(:gid).and_return(501)
+      allow(lstat).to receive(:mode).and_return(0777)
+      allow(File).to receive(:lstat).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(lstat)
+      allow(provider.file_class).to receive(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+      allow(provider.file_class).to receive(:readlink).with("#{CHEF_SPEC_DATA}/fofile-link").and_return("#{CHEF_SPEC_DATA}/fofile")
     end
 
     describe "to a file that exists" do
       before do
-        File.stub(:exist?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+        allow(File).to receive(:exist?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
         new_resource.owner 501 # only loaded in current_resource if present in new
         new_resource.group 501
         provider.load_current_resource
       end
 
       it "should set the symlink target" do
-        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+        expect(provider.current_resource.target_file).to eq("#{CHEF_SPEC_DATA}/fofile-link")
       end
       it "should set the link type" do
-        provider.current_resource.link_type.should == :symbolic
+        expect(provider.current_resource.link_type).to eq(:symbolic)
       end
       it "should update the source of the existing link with the links target" do
-        paths_eql?(provider.current_resource.to, "#{CHEF_SPEC_DATA}/fofile").should be_true
+        expect(paths_eql?(provider.current_resource.to, "#{CHEF_SPEC_DATA}/fofile")).to be_true
       end
       it "should set the owner" do
-        provider.current_resource.owner.should == 501
+        expect(provider.current_resource.owner).to eq(501)
       end
       it "should set the group" do
-        provider.current_resource.group.should == 501
+        expect(provider.current_resource.group).to eq(501)
       end
 
       # We test create in unit tests because there is no other way to ensure
@@ -87,7 +87,7 @@ describe Chef::Resource::Link, :not_supported_on_win2k3 do
           result
         end
         it 'create does no work' do
-          provider.access_controls.should_not_receive(:set_all)
+          expect(provider.access_controls).not_to receive(:set_all)
           provider.run_action(:create)
         end
       end
@@ -95,139 +95,139 @@ describe Chef::Resource::Link, :not_supported_on_win2k3 do
 
     describe "to a file that doesn't exist" do
       before do
-        File.stub(:exist?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
-        provider.file_class.stub(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
-        provider.file_class.stub(:readlink).with("#{CHEF_SPEC_DATA}/fofile-link").and_return("#{CHEF_SPEC_DATA}/fofile")
+        allow(File).to receive(:exist?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+        allow(provider.file_class).to receive(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+        allow(provider.file_class).to receive(:readlink).with("#{CHEF_SPEC_DATA}/fofile-link").and_return("#{CHEF_SPEC_DATA}/fofile")
         new_resource.owner "501" # only loaded in current_resource if present in new
         new_resource.group "501"
         provider.load_current_resource
       end
 
       it "should set the symlink target" do
-        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+        expect(provider.current_resource.target_file).to eq("#{CHEF_SPEC_DATA}/fofile-link")
       end
       it "should set the link type" do
-        provider.current_resource.link_type.should == :symbolic
+        expect(provider.current_resource.link_type).to eq(:symbolic)
       end
       it "should update the source of the existing link to the link's target" do
-        paths_eql?(provider.current_resource.to, "#{CHEF_SPEC_DATA}/fofile").should be_true
+        expect(paths_eql?(provider.current_resource.to, "#{CHEF_SPEC_DATA}/fofile")).to be_true
       end
       it "should not set the owner" do
-        provider.current_resource.owner.should be_nil
+        expect(provider.current_resource.owner).to be_nil
       end
       it "should not set the group" do
-        provider.current_resource.group.should be_nil
+        expect(provider.current_resource.group).to be_nil
       end
     end
   end
 
   describe "when the target doesn't exist" do
     before do
-      File.stub(:exists?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
-      provider.file_class.stub(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+      allow(File).to receive(:exists?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+      allow(provider.file_class).to receive(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
       provider.load_current_resource
     end
 
     it "should set the symlink target" do
-      provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+      expect(provider.current_resource.target_file).to eq("#{CHEF_SPEC_DATA}/fofile-link")
     end
     it "should update the source of the existing link to nil" do
-      provider.current_resource.to.should be_nil
+      expect(provider.current_resource.to).to be_nil
     end
     it "should not set the owner" do
-      provider.current_resource.owner.should == nil
+      expect(provider.current_resource.owner).to eq(nil)
     end
     it "should not set the group" do
-      provider.current_resource.group.should == nil
+      expect(provider.current_resource.group).to eq(nil)
     end
   end
 
   describe "when the target is a regular old file" do
     before do
       stat = double("stats", :ino => 5)
-      stat.stub(:uid).and_return(501)
-      stat.stub(:gid).and_return(501)
-      stat.stub(:mode).and_return(0755)
-      provider.file_class.stub(:stat).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(stat)
+      allow(stat).to receive(:uid).and_return(501)
+      allow(stat).to receive(:gid).and_return(501)
+      allow(stat).to receive(:mode).and_return(0755)
+      allow(provider.file_class).to receive(:stat).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(stat)
 
-      File.stub(:exists?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
-      provider.file_class.stub(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
+      allow(File).to receive(:exists?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(true)
+      allow(provider.file_class).to receive(:symlink?).with("#{CHEF_SPEC_DATA}/fofile-link").and_return(false)
     end
 
     describe "and the source does not exist" do
       before do
-        File.stub(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(false)
+        allow(File).to receive(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(false)
         provider.load_current_resource
       end
 
       it "should set the symlink target" do
-        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+        expect(provider.current_resource.target_file).to eq("#{CHEF_SPEC_DATA}/fofile-link")
       end
       it "should update the current source of the existing link with an empty string" do
-        provider.current_resource.to.should == ''
+        expect(provider.current_resource.to).to eq('')
       end
       it "should not set the owner" do
-        provider.current_resource.owner.should == nil
+        expect(provider.current_resource.owner).to eq(nil)
       end
       it "should not set the group" do
-        provider.current_resource.group.should == nil
+        expect(provider.current_resource.group).to eq(nil)
       end
     end
 
     describe "and the source exists" do
       before do
         stat = double("stats", :ino => 6)
-        stat.stub(:uid).and_return(502)
-        stat.stub(:gid).and_return(502)
-        stat.stub(:mode).and_return(0644)
+        allow(stat).to receive(:uid).and_return(502)
+        allow(stat).to receive(:gid).and_return(502)
+        allow(stat).to receive(:mode).and_return(0644)
 
-        provider.file_class.stub(:stat).with("#{CHEF_SPEC_DATA}/fofile").and_return(stat)
+        allow(provider.file_class).to receive(:stat).with("#{CHEF_SPEC_DATA}/fofile").and_return(stat)
 
-        File.stub(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(true)
+        allow(File).to receive(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(true)
         provider.load_current_resource
       end
 
       it "should set the symlink target" do
-        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+        expect(provider.current_resource.target_file).to eq("#{CHEF_SPEC_DATA}/fofile-link")
       end
       it "should update the current source of the existing link with an empty string" do
-        provider.current_resource.to.should == ''
+        expect(provider.current_resource.to).to eq('')
       end
       it "should not set the owner" do
-        provider.current_resource.owner.should == nil
+        expect(provider.current_resource.owner).to eq(nil)
       end
       it "should not set the group" do
-        provider.current_resource.group.should == nil
+        expect(provider.current_resource.group).to eq(nil)
       end
     end
 
     describe "and is hardlinked to the source" do
       before do
         stat = double("stats", :ino => 5)
-        stat.stub(:uid).and_return(502)
-        stat.stub(:gid).and_return(502)
-        stat.stub(:mode).and_return(0644)
+        allow(stat).to receive(:uid).and_return(502)
+        allow(stat).to receive(:gid).and_return(502)
+        allow(stat).to receive(:mode).and_return(0644)
 
-        provider.file_class.stub(:stat).with("#{CHEF_SPEC_DATA}/fofile").and_return(stat)
+        allow(provider.file_class).to receive(:stat).with("#{CHEF_SPEC_DATA}/fofile").and_return(stat)
 
-        File.stub(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(true)
+        allow(File).to receive(:exists?).with("#{CHEF_SPEC_DATA}/fofile").and_return(true)
         provider.load_current_resource
       end
 
       it "should set the symlink target" do
-        provider.current_resource.target_file.should == "#{CHEF_SPEC_DATA}/fofile-link"
+        expect(provider.current_resource.target_file).to eq("#{CHEF_SPEC_DATA}/fofile-link")
       end
       it "should set the link type" do
-        provider.current_resource.link_type.should == :hard
+        expect(provider.current_resource.link_type).to eq(:hard)
       end
       it "should update the source of the existing link to the link's target" do
-        paths_eql?(provider.current_resource.to, "#{CHEF_SPEC_DATA}/fofile").should be_true
+        expect(paths_eql?(provider.current_resource.to, "#{CHEF_SPEC_DATA}/fofile")).to be_true
       end
       it "should not set the owner" do
-        provider.current_resource.owner.should == nil
+        expect(provider.current_resource.owner).to eq(nil)
       end
       it "should not set the group" do
-        provider.current_resource.group.should == nil
+        expect(provider.current_resource.group).to eq(nil)
       end
 
       # We test create in unit tests because there is no other way to ensure
@@ -241,9 +241,9 @@ describe Chef::Resource::Link, :not_supported_on_win2k3 do
           result
         end
         it 'create does no work' do
-          provider.file_class.should_not_receive(:symlink)
-          provider.file_class.should_not_receive(:link)
-          provider.access_controls.should_not_receive(:set_all)
+          expect(provider.file_class).not_to receive(:symlink)
+          expect(provider.file_class).not_to receive(:link)
+          expect(provider.access_controls).not_to receive(:set_all)
           provider.run_action(:create)
         end
       end

data/spec/unit/provider/log_spec.rb

@@ -32,10 +32,6 @@ describe Chef::Provider::Log::ChefLog do
 
   let(:provider) { Chef::Provider::Log::ChefLog.new(new_resource, run_context) }
 
-  it "should be registered with the default platform hash" do
-    expect(Chef::Platform.platforms[:default][:log]).not_to be_nil
-  end
-
   it "should write the string to the Chef::Log object at default level (info)" do
     expect(Chef::Log).to receive(:info).with(log_str).and_return(true)
     provider.run_action(:write)

data/spec/unit/provider/mdadm_spec.rb

@@ -32,22 +32,22 @@ describe Chef::Provider::Mdadm do
 
   describe "when determining the current metadevice status" do
     it "should set the current resources mount point to the new resources mount point" do
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:status => 0))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:status => 0))
       @provider.load_current_resource
-      @provider.current_resource.name.should == '/dev/md1'
-      @provider.current_resource.raid_device.should == '/dev/md1'
+      expect(@provider.current_resource.name).to eq('/dev/md1')
+      expect(@provider.current_resource.raid_device).to eq('/dev/md1')
     end
 
     it "determines that the metadevice exists when mdadm exit code is zero" do
-      @provider.stub(:shell_out!).with("mdadm --detail --test /dev/md1", :returns => [0,4]).and_return(OpenStruct.new(:status => 0))
+      allow(@provider).to receive(:shell_out!).with("mdadm --detail --test /dev/md1", :returns => [0,4]).and_return(OpenStruct.new(:status => 0))
       @provider.load_current_resource
-      @provider.current_resource.exists.should be_true
+      expect(@provider.current_resource.exists).to be_true
     end
 
     it "determines that the metadevice does not exist when mdadm exit code is 4" do
-      @provider.stub(:shell_out!).with("mdadm --detail --test /dev/md1", :returns => [0,4]).and_return(OpenStruct.new(:status => 4))
+      allow(@provider).to receive(:shell_out!).with("mdadm --detail --test /dev/md1", :returns => [0,4]).and_return(OpenStruct.new(:status => 4))
       @provider.load_current_resource
-      @provider.current_resource.exists.should be_false
+      expect(@provider.current_resource.exists).to be_false
     end
   end
 
@@ -55,7 +55,7 @@ describe Chef::Provider::Mdadm do
     before(:each) do
       @current_resource = Chef::Resource::Mdadm.new('/dev/md1')
       @new_resource.level 5
-      @provider.stub(:load_current_resource).and_return(true)
+      allow(@provider).to receive(:load_current_resource).and_return(true)
       @provider.current_resource = @current_resource
     end
 
@@ -63,7 +63,7 @@ describe Chef::Provider::Mdadm do
       it "should create the raid device if it doesnt exist" do
         @current_resource.exists(false)
         expected_command = "yes | mdadm --create /dev/md1 --level 5 --chunk=16 --metadata=0.90 --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        @provider.should_receive(:shell_out!).with(expected_command)
+        expect(@provider).to receive(:shell_out!).with(expected_command)
         @provider.run_action(:create)
       end
 
@@ -71,25 +71,25 @@ describe Chef::Provider::Mdadm do
         @current_resource.exists(false)
         @new_resource.bitmap('grow')
         expected_command = "yes | mdadm --create /dev/md1 --level 5 --chunk=16 --metadata=0.90 --bitmap=grow --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        @provider.should_receive(:shell_out!).with(expected_command)
+        expect(@provider).to receive(:shell_out!).with(expected_command)
         @provider.run_action(:create)
-        @new_resource.should be_updated_by_last_action
+        expect(@new_resource).to be_updated_by_last_action
       end
 
       it "should not specify a chunksize if raid level 1" do
         @current_resource.exists(false)
         @new_resource.level 1
         expected_command = "yes | mdadm --create /dev/md1 --level 1 --metadata=0.90 --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        @provider.should_receive(:shell_out!).with(expected_command)
+        expect(@provider).to receive(:shell_out!).with(expected_command)
         @provider.run_action(:create)
-        @new_resource.should be_updated_by_last_action
+        expect(@new_resource).to be_updated_by_last_action
       end
 
       it "should not create the raid device if it does exist" do
         @current_resource.exists(true)
-        @provider.should_not_receive(:shell_out!)
+        expect(@provider).not_to receive(:shell_out!)
         @provider.run_action(:create)
-        @new_resource.should_not be_updated_by_last_action
+        expect(@new_resource).not_to be_updated_by_last_action
       end
     end
 
@@ -97,16 +97,16 @@ describe Chef::Provider::Mdadm do
       it "should assemble the raid device if it doesnt exist" do
         @current_resource.exists(false)
         expected_mdadm_cmd = "yes | mdadm --assemble /dev/md1 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        @provider.should_receive(:shell_out!).with(expected_mdadm_cmd)
+        expect(@provider).to receive(:shell_out!).with(expected_mdadm_cmd)
         @provider.run_action(:assemble)
-        @new_resource.should be_updated_by_last_action
+        expect(@new_resource).to be_updated_by_last_action
       end
 
         it "should not assemble the raid device if it doesnt exist" do
         @current_resource.exists(true)
-        @provider.should_not_receive(:shell_out!)
+        expect(@provider).not_to receive(:shell_out!)
         @provider.run_action(:assemble)
-        @new_resource.should_not be_updated_by_last_action
+        expect(@new_resource).not_to be_updated_by_last_action
       end
     end
 
@@ -115,16 +115,16 @@ describe Chef::Provider::Mdadm do
       it "should stop the raid device if it exists" do
         @current_resource.exists(true)
         expected_mdadm_cmd = "yes | mdadm --stop /dev/md1"
-        @provider.should_receive(:shell_out!).with(expected_mdadm_cmd)
+        expect(@provider).to receive(:shell_out!).with(expected_mdadm_cmd)
         @provider.run_action(:stop)
-        @new_resource.should be_updated_by_last_action
+        expect(@new_resource).to be_updated_by_last_action
       end
 
       it "should not attempt to stop the raid device if it does not exist" do
         @current_resource.exists(false)
-        @provider.should_not_receive(:shell_out!)
+        expect(@provider).not_to receive(:shell_out!)
         @provider.run_action(:stop)
-        @new_resource.should_not be_updated_by_last_action
+        expect(@new_resource).not_to be_updated_by_last_action
       end
     end
   end

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

@@ -60,18 +60,18 @@ ENABLED
 
     @provider = Chef::Provider::Mount::Aix.new(@new_resource, @run_context)
 
-    ::File.stub(:exists?).with("/dev/sdz1").and_return true
-    ::File.stub(:exists?).with("/tmp/foo").and_return true
+    allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
+    allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
   end
 
   def stub_mounted(provider, mounted_output)
     response = double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => mounted_output, :stderr => "")
-    provider.should_receive(:shell_out!).with("mount").and_return(response)
+    expect(provider).to receive(:shell_out!).with("mount").and_return(response)
   end
 
   def stub_enabled(provider, enabled_output)
     response = double("Mixlib::ShellOut command", :exitstatus => 0, :stdout => enabled_output, :stderr => "")
-    provider.should_receive(:shell_out).with("lsfs -c #{@new_resource.mount_point}").and_return(response)
+    expect(provider).to receive(:shell_out).with("lsfs -c #{@new_resource.mount_point}").and_return(response)
   end
 
   def stub_mounted_enabled(provider, mounted_output, enabled_output)
@@ -121,7 +121,7 @@ ENABLED
     it "should mount resource if it is not mounted" do
       stub_mounted_enabled(@provider, @unmounted_output, "")
 
-      @provider.should_receive(:shell_out!).with("mount -v #{@new_resource.fstype} #{@new_resource.device} #{@new_resource.mount_point}")
+      expect(@provider).to receive(:shell_out!).with("mount -v #{@new_resource.fstype} #{@new_resource.device} #{@new_resource.mount_point}")
 
       @provider.run_action(:mount)
     end
@@ -129,7 +129,7 @@ ENABLED
     it "should not mount resource if it is already mounted" do
       stub_mounted_enabled(@provider, @mounted_output, "")
 
-      @provider.should_not_receive(:mount_fs)
+      expect(@provider).not_to receive(:mount_fs)
 
       @provider.run_action(:mount)
     end
@@ -139,7 +139,7 @@ ENABLED
     it "should umount resource if it is already mounted" do
       stub_mounted_enabled(@provider, @mounted_output, "")
 
-      @provider.should_receive(:shell_out!).with("umount #{@new_resource.mount_point}")
+      expect(@provider).to receive(:shell_out!).with("umount #{@new_resource.mount_point}")
 
       @provider.run_action(:umount)
     end
@@ -147,7 +147,7 @@ ENABLED
     it "should not umount resource if it is not mounted" do
       stub_mounted_enabled(@provider, @unmounted_output, "")
 
-      @provider.should_not_receive(:umount_fs)
+      expect(@provider).not_to receive(:umount_fs)
 
       @provider.run_action(:umount)
     end
@@ -158,7 +158,7 @@ ENABLED
       @new_resource.supports({:remount => true})
       stub_mounted_enabled(@provider, @mounted_output, "")
 
-      @provider.should_receive(:shell_out!).with("mount -o remount #{@new_resource.device} #{@new_resource.mount_point}")
+      expect(@provider).to receive(:shell_out!).with("mount -o remount #{@new_resource.device} #{@new_resource.mount_point}")
 
       @provider.run_action(:remount)
     end
@@ -168,7 +168,7 @@ ENABLED
       @new_resource.options("nodev,rw")
       stub_mounted_enabled(@provider, @mounted_output, "")
 
-      @provider.should_receive(:shell_out!).with("mount -o remount,nodev,rw #{@new_resource.device} #{@new_resource.mount_point}")
+      expect(@provider).to receive(:shell_out!).with("mount -o remount,nodev,rw #{@new_resource.device} #{@new_resource.mount_point}")
 
       @provider.run_action(:remount)
     end
@@ -179,18 +179,18 @@ ENABLED
       @new_resource.options("nodev,rw")
       stub_mounted_enabled(@provider, @mounted_output, "")
       filesystems = StringIO.new
-      ::File.stub(:open).with("/etc/filesystems", "a").and_yield(filesystems)
+      allow(::File).to receive(:open).with("/etc/filesystems", "a").and_yield(filesystems)
 
       @provider.run_action(:enable)
 
-      filesystems.string.should match(%r{^/tmp/foo:\n\tdev\t\t= /dev/sdz1\n\tvfs\t\t= jfs2\n\tmount\t\t= false\n\toptions\t\t= nodev,rw\n$})
+      expect(filesystems.string).to match(%r{^/tmp/foo:\n\tdev\t\t= /dev/sdz1\n\tvfs\t\t= jfs2\n\tmount\t\t= false\n\toptions\t\t= nodev,rw\n$})
     end
 
     it "should not enable mount if it is mounted and already enabled and mount options are unchanged" do
       stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
       @new_resource.options "rw"
 
-      @provider.should_not_receive(:enable_fs)
+      expect(@provider).not_to receive(:enable_fs)
 
       @provider.run_action(:enable)
     end
@@ -200,7 +200,7 @@ ENABLED
     it "should disable mount if it is mounted and enabled" do
       stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
 
-      ::File.stub(:open).with("/etc/filesystems", "r").and_return(<<-ETCFILESYSTEMS)
+      allow(::File).to receive(:open).with("/etc/filesystems", "r").and_return(<<-ETCFILESYSTEMS)
 /tmp/foo:
   dev   = /dev/sdz1
   vfs   = jfs2
@@ -219,17 +219,17 @@ ENABLED
 ETCFILESYSTEMS
 
       filesystems = StringIO.new
-      ::File.stub(:open).with("/etc/filesystems", "w").and_yield(filesystems)
+      allow(::File).to receive(:open).with("/etc/filesystems", "w").and_yield(filesystems)
 
       @provider.run_action(:disable)
 
-      filesystems.string.should match(%r{^/tmp/abc:\s+dev\s+= /dev/sdz2\s+vfs\s+= jfs2\s+mount\s+= true\s+options\s+= rw\n$})
+      expect(filesystems.string).to match(%r{^/tmp/abc:\s+dev\s+= /dev/sdz2\s+vfs\s+= jfs2\s+mount\s+= true\s+options\s+= rw\n$})
     end
 
     it "should not disable mount if it is not mounted" do
       stub_mounted_enabled(@provider, @unmounted_output, "")
 
-      @provider.should_not_receive(:disable_fs)
+      expect(@provider).not_to receive(:disable_fs)
 
       @provider.run_action(:disable)
     end