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

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

@@ -34,30 +34,30 @@ describe Chef::Provider::Mount::Mount do
 
     @provider = Chef::Provider::Mount::Mount.new(@new_resource, @run_context)
 
-    ::File.stub(:exists?).with("/dev/sdz1").and_return true
-    ::File.stub(:exists?).with("/tmp/foo").and_return true
-    ::File.stub(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
-    ::File.stub(:realpath).with("/tmp/foo").and_return "/tmp/foo"
+    allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
+    allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
+    allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
+    allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
   end
 
   describe "when discovering the current fs state" do
     before do
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => ''))
-      ::File.stub(:foreach).with("/etc/fstab")
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => ''))
+      allow(::File).to receive(:foreach).with("/etc/fstab")
     end
 
     it "should create a current resource with the same mount point and device" do
       @provider.load_current_resource
-      @provider.current_resource.name.should == '/tmp/foo'
-      @provider.current_resource.mount_point.should == '/tmp/foo'
-      @provider.current_resource.device.should == '/dev/sdz1'
+      expect(@provider.current_resource.name).to eq('/tmp/foo')
+      expect(@provider.current_resource.mount_point).to eq('/tmp/foo')
+      expect(@provider.current_resource.device).to eq('/dev/sdz1')
     end
 
     it "should accecpt device_type :uuid", :not_supported_on_solaris do
       @new_resource.device_type :uuid
       @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
       @stdout_findfs = double("STDOUT", :first => "/dev/sdz1")
-      @provider.should_receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,@stdout_findfs,@stderr).and_return(@status)
+      expect(@provider).to receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,@stdout_findfs,@stderr).and_return(@status)
       @provider.load_current_resource()
       @provider.mountable?
     end
@@ -67,28 +67,28 @@ describe Chef::Provider::Mount::Mount do
         "cifs" => "//cifsserver/share" }.each do |type, fs_spec|
         it "should detect network fs_spec (#{type})" do
           @new_resource.device fs_spec
-          @provider.network_device?.should be_true
+          expect(@provider.network_device?).to be_true
         end
 
         it "should ignore trailing slash and set mounted to true for network mount (#{type})" do
           @new_resource.device fs_spec
-          @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => "#{fs_spec}/ on /tmp/foo type #{type} (rw)\n"))
+          allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "#{fs_spec}/ on /tmp/foo type #{type} (rw)\n"))
           @provider.load_current_resource
-          @provider.current_resource.mounted.should be_true
+          expect(@provider.current_resource.mounted).to be_true
         end
       end
     end
 
     it "should raise an error if the mount device does not exist" do
-      ::File.stub(:exists?).with("/dev/sdz1").and_return false
-      lambda { @provider.load_current_resource();@provider.mountable? }.should raise_error(Chef::Exceptions::Mount)
+      allow(::File).to receive(:exists?).with("/dev/sdz1").and_return false
+      expect { @provider.load_current_resource();@provider.mountable? }.to raise_error(Chef::Exceptions::Mount)
     end
 
     it "should not call mountable? with load_current_resource - CHEF-1565" do
-      ::File.stub(:exists?).with("/dev/sdz1").and_return false
-      @provider.should_receive(:mounted?).and_return(true)
-      @provider.should_receive(:enabled?).and_return(true)
-      @provider.should_not_receive(:mountable?)
+      allow(::File).to receive(:exists?).with("/dev/sdz1").and_return false
+      expect(@provider).to receive(:mounted?).and_return(true)
+      expect(@provider).to receive(:enabled?).and_return(true)
+      expect(@provider).not_to receive(:mountable?)
       @provider.load_current_resource
     end
 
@@ -97,55 +97,51 @@ describe Chef::Provider::Mount::Mount do
       @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
       status_findfs = double("Status", :exitstatus => 1)
       stdout_findfs = double("STDOUT", :first => nil)
-      @provider.should_receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,stdout_findfs,@stderr).and_return(status_findfs)
-      ::File.should_receive(:exists?).with("").and_return(false)
-      lambda { @provider.load_current_resource();@provider.mountable? }.should raise_error(Chef::Exceptions::Mount)
+      expect(@provider).to receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,stdout_findfs,@stderr).and_return(status_findfs)
+      expect(::File).to receive(:exists?).with("").and_return(false)
+      expect { @provider.load_current_resource();@provider.mountable? }.to raise_error(Chef::Exceptions::Mount)
     end
 
     it "should raise an error if the mount point does not exist" do
-      ::File.stub(:exists?).with("/tmp/foo").and_return false
-      lambda { @provider.load_current_resource();@provider.mountable? }.should raise_error(Chef::Exceptions::Mount)
+      allow(::File).to receive(:exists?).with("/tmp/foo").and_return false
+      expect { @provider.load_current_resource();@provider.mountable? }.to raise_error(Chef::Exceptions::Mount)
     end
 
-    it "does not expect the device to exist for tmpfs" do
-      @new_resource.fstype("tmpfs")
-      @new_resource.device("whatever")
-      lambda { @provider.load_current_resource();@provider.mountable? }.should_not raise_error
-    end
-
-    it "does not expect the device to exist for Fuse filesystems" do
-      @new_resource.fstype("fuse")
-      @new_resource.device("nilfs#xxx")
-      lambda { @provider.load_current_resource();@provider.mountable? }.should_not raise_error
+    [ "tmpfs", "fuse", "cgroup" ].each do |fstype|
+      it "does not expect the device to exist for #{fstype}" do
+        @new_resource.fstype(fstype)
+        @new_resource.device("whatever")
+        expect { @provider.load_current_resource();@provider.mountable? }.not_to raise_error
+      end
     end
 
     it "does not expect the device to exist if it's none" do
       @new_resource.device("none")
-      lambda { @provider.load_current_resource();@provider.mountable? }.should_not raise_error
+      expect { @provider.load_current_resource();@provider.mountable? }.not_to raise_error
     end
 
     it "should set mounted true if the mount point is found in the mounts list" do
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdz1 on /tmp/foo type ext3 (rw)\n"))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdz1 on /tmp/foo type ext3 (rw)\n"))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_true
+      expect(@provider.current_resource.mounted).to be_true
     end
 
     it "should set mounted false if another mount point beginning with the same path is found in the mounts list" do
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdz1 on /tmp/foobar type ext3 (rw)\n"))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdz1 on /tmp/foobar type ext3 (rw)\n"))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_false
+      expect(@provider.current_resource.mounted).to be_false
     end
 
     it "should set mounted true if the symlink target of the device is found in the mounts list" do
       # expand the target path to correct specs on Windows
       target = ::File.expand_path('/dev/mapper/target')
 
-      ::File.stub(:symlink?).with("#{@new_resource.device}").and_return(true)
-      ::File.stub(:readlink).with("#{@new_resource.device}").and_return(target)
+      allow(::File).to receive(:symlink?).with("#{@new_resource.device}").and_return(true)
+      allow(::File).to receive(:readlink).with("#{@new_resource.device}").and_return(target)
 
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => "#{target} on /tmp/foo type ext3 (rw)\n"))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "#{target} on /tmp/foo type ext3 (rw)\n"))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_true
+      expect(@provider.current_resource.mounted).to be_true
     end
 
     it "should set mounted true if the symlink target of the device is relative and is found in the mounts list - CHEF-4957" do
@@ -154,109 +150,109 @@ describe Chef::Provider::Mount::Mount do
       # expand the target path to correct specs on Windows
       absolute_target = ::File.expand_path("/dev/xsdz1")
 
-      ::File.stub(:symlink?).with("#{@new_resource.device}").and_return(true)
-      ::File.stub(:readlink).with("#{@new_resource.device}").and_return(target)
+      allow(::File).to receive(:symlink?).with("#{@new_resource.device}").and_return(true)
+      allow(::File).to receive(:readlink).with("#{@new_resource.device}").and_return(target)
 
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => "#{absolute_target} on /tmp/foo type ext3 (rw)\n"))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "#{absolute_target} on /tmp/foo type ext3 (rw)\n"))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_true
+      expect(@provider.current_resource.mounted).to be_true
     end
 
     it "should set mounted true if the mount point is found last in the mounts list" do
       mount = "/dev/sdy1 on #{@new_resource.mount_point} type ext3 (rw)\n"
       mount << "#{@new_resource.device} on #{@new_resource.mount_point} type ext3 (rw)\n"
 
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => mount))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => mount))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_true
+      expect(@provider.current_resource.mounted).to be_true
     end
 
     it "should set mounted false if the mount point is not last in the mounts list" do
       mount = "#{@new_resource.device} on #{@new_resource.mount_point} type ext3 (rw)\n"
       mount << "/dev/sdy1 on #{@new_resource.mount_point} type ext3 (rw)\n"
 
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => mount))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => mount))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_false
+      expect(@provider.current_resource.mounted).to be_false
     end
 
     it "mounted should be false if the mount point is not found in the mounts list" do
-      @provider.stub(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdy1 on /tmp/foo type ext3 (rw)\n"))
+      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(:stdout => "/dev/sdy1 on /tmp/foo type ext3 (rw)\n"))
       @provider.load_current_resource()
-      @provider.current_resource.mounted.should be_false
+      expect(@provider.current_resource.mounted).to be_false
     end
 
     it "should set enabled to true if the mount point is last in fstab" do
       fstab1 = "/dev/sdy1  /tmp/foo  ext3  defaults  1 2\n"
       fstab2 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
 
-      ::File.stub(:foreach).with("/etc/fstab").and_yield(fstab1).and_yield(fstab2)
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield(fstab1).and_yield(fstab2)
 
       @provider.load_current_resource
-      @provider.current_resource.enabled.should be_true
+      expect(@provider.current_resource.enabled).to be_true
     end
 
     it "should set enabled to true if the mount point is not last in fstab and mount_point is a substring of another mount" do
       fstab1 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
       fstab2 = "/dev/sdy1  /tmp/foo/bar  ext3  defaults  1 2\n"
 
-      ::File.stub(:foreach).with("/etc/fstab").and_yield(fstab1).and_yield(fstab2)
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield(fstab1).and_yield(fstab2)
 
       @provider.load_current_resource
-      @provider.current_resource.enabled.should be_true
+      expect(@provider.current_resource.enabled).to be_true
     end
 
     it "should set enabled to true if the symlink target is in fstab" do
       target = "/dev/mapper/target"
 
-      ::File.stub(:symlink?).with("#{@new_resource.device}").and_return(true)
-      ::File.stub(:readlink).with("#{@new_resource.device}").and_return(target)
+      allow(::File).to receive(:symlink?).with("#{@new_resource.device}").and_return(true)
+      allow(::File).to receive(:readlink).with("#{@new_resource.device}").and_return(target)
 
       fstab = "/dev/sdz1  /tmp/foo ext3  defaults  1 2\n"
 
-      ::File.stub(:foreach).with("/etc/fstab").and_yield fstab
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield fstab
 
       @provider.load_current_resource
-      @provider.current_resource.enabled.should be_true
+      expect(@provider.current_resource.enabled).to be_true
     end
 
     it "should set enabled to true if the symlink target is relative and is in fstab - CHEF-4957" do
       target = "xsdz1"
 
-      ::File.stub(:symlink?).with("#{@new_resource.device}").and_return(true)
-      ::File.stub(:readlink).with("#{@new_resource.device}").and_return(target)
+      allow(::File).to receive(:symlink?).with("#{@new_resource.device}").and_return(true)
+      allow(::File).to receive(:readlink).with("#{@new_resource.device}").and_return(target)
 
       fstab = "/dev/sdz1  /tmp/foo ext3  defaults  1 2\n"
 
-      ::File.stub(:foreach).with("/etc/fstab").and_yield fstab
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield fstab
 
       @provider.load_current_resource
-      @provider.current_resource.enabled.should be_true
+      expect(@provider.current_resource.enabled).to be_true
     end
 
     it "should set enabled to false if the mount point is not in fstab" do
       fstab = "/dev/sdy1  #{@new_resource.mount_point}  ext3  defaults  1 2\n"
-      ::File.stub(:foreach).with("/etc/fstab").and_yield fstab
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield fstab
 
       @provider.load_current_resource
-      @provider.current_resource.enabled.should be_false
+      expect(@provider.current_resource.enabled).to be_false
     end
 
     it "should ignore commented lines in fstab " do
        fstab = "\# #{@new_resource.device}  #{@new_resource.mount_point}  ext3  defaults  1 2\n"
-       ::File.stub(:foreach).with("/etc/fstab").and_yield fstab
+       allow(::File).to receive(:foreach).with("/etc/fstab").and_yield fstab
 
        @provider.load_current_resource
-       @provider.current_resource.enabled.should be_false
+       expect(@provider.current_resource.enabled).to be_false
      end
 
     it "should set enabled to false if the mount point is not last in fstab" do
       line_1 = "#{@new_resource.device} #{@new_resource.mount_point}  ext3  defaults  1 2\n"
       line_2 = "/dev/sdy1 #{@new_resource.mount_point}  ext3  defaults  1 2\n"
-      ::File.stub(:foreach).with("/etc/fstab").and_yield(line_1).and_yield(line_2)
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield(line_1).and_yield(line_2)
 
       @provider.load_current_resource
-      @provider.current_resource.enabled.should be_false
+      expect(@provider.current_resource.enabled).to be_false
     end
 
     it "should not mangle the mount options if the device in fstab is a symlink" do
@@ -264,26 +260,26 @@ describe Chef::Provider::Mount::Mount do
       target = "/dev/mapper/target"
       options = "rw,noexec,noauto"
 
-      ::File.stub(:symlink?).with(@new_resource.device).and_return(true)
-      ::File.stub(:readlink).with(@new_resource.device).and_return(target)
+      allow(::File).to receive(:symlink?).with(@new_resource.device).and_return(true)
+      allow(::File).to receive(:readlink).with(@new_resource.device).and_return(target)
 
       fstab = "#{@new_resource.device} #{@new_resource.mount_point} #{@new_resource.fstype} #{options} 1 2\n"
-      ::File.stub(:foreach).with("/etc/fstab").and_yield fstab
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield fstab
       @provider.load_current_resource
-      @provider.current_resource.options.should eq(options.split(','))
+      expect(@provider.current_resource.options).to eq(options.split(','))
     end
 
     it "should not mangle the mount options if the symlink target is in fstab" do
       target = ::File.expand_path("/dev/mapper/target")
       options = "rw,noexec,noauto"
 
-      ::File.stub(:symlink?).with(@new_resource.device).and_return(true)
-      ::File.stub(:readlink).with(@new_resource.device).and_return(target)
+      allow(::File).to receive(:symlink?).with(@new_resource.device).and_return(true)
+      allow(::File).to receive(:readlink).with(@new_resource.device).and_return(target)
 
       fstab = "#{target} #{@new_resource.mount_point} #{@new_resource.fstype} #{options} 1 2\n"
-      ::File.stub(:foreach).with("/etc/fstab").and_yield fstab
+      allow(::File).to receive(:foreach).with("/etc/fstab").and_yield fstab
       @provider.load_current_resource
-      @provider.current_resource.options.should eq(options.split(','))
+      expect(@provider.current_resource.options).to eq(options.split(','))
     end
   end
 
@@ -299,14 +295,14 @@ describe Chef::Provider::Mount::Mount do
 
     describe "mount_fs" do
       it "should mount the filesystem if it is not mounted" do
-        @provider.should_receive(:shell_out!).with("mount -t ext3 -o defaults /dev/sdz1 /tmp/foo")
+        expect(@provider).to receive(:shell_out!).with("mount -t ext3 -o defaults /dev/sdz1 /tmp/foo")
         @provider.mount_fs()
       end
 
       it "should mount the filesystem with options if options were passed" do
         options = "rw,noexec,noauto"
         @new_resource.options(%w{rw noexec noauto})
-        @provider.should_receive(:shell_out!).with("mount -t ext3 -o rw,noexec,noauto /dev/sdz1 /tmp/foo")
+        expect(@provider).to receive(:shell_out!).with("mount -t ext3 -o rw,noexec,noauto /dev/sdz1 /tmp/foo")
         @provider.mount_fs()
       end
 
@@ -314,16 +310,16 @@ describe Chef::Provider::Mount::Mount do
         @new_resource.device "d21afe51-a0fe-4dc6-9152-ac733763ae0a"
         @new_resource.device_type :uuid
         @stdout_findfs = double("STDOUT", :first => "/dev/sdz1")
-        @provider.stub(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,@stdout_findfs,@stderr).and_return(@status)
+        allow(@provider).to receive(:popen4).with("/sbin/findfs UUID=d21afe51-a0fe-4dc6-9152-ac733763ae0a").and_yield(@pid,@stdin,@stdout_findfs,@stderr).and_return(@status)
         @stdout_mock = double('stdout mock')
-        @stdout_mock.stub(:each).and_yield("#{@new_resource.device} on #{@new_resource.mount_point}")
-        @provider.should_receive(:shell_out!).with("mount -t #{@new_resource.fstype} -o defaults -U #{@new_resource.device} #{@new_resource.mount_point}").and_return(@stdout_mock)
+        allow(@stdout_mock).to receive(:each).and_yield("#{@new_resource.device} on #{@new_resource.mount_point}")
+        expect(@provider).to receive(:shell_out!).with("mount -t #{@new_resource.fstype} -o defaults -U #{@new_resource.device} #{@new_resource.mount_point}").and_return(@stdout_mock)
         @provider.mount_fs()
       end
 
       it "should not mount the filesystem if it is mounted" do
-        @current_resource.stub(:mounted).and_return(true)
-        @provider.should_not_receive(:shell_out!)
+        allow(@current_resource).to receive(:mounted).and_return(true)
+        expect(@provider).not_to receive(:shell_out!)
         @provider.mount_fs()
       end
 
@@ -332,13 +328,13 @@ describe Chef::Provider::Mount::Mount do
     describe "umount_fs" do
       it "should umount the filesystem if it is mounted" do
         @current_resource.mounted(true)
-        @provider.should_receive(:shell_out!).with("umount /tmp/foo")
+        expect(@provider).to receive(:shell_out!).with("umount /tmp/foo")
         @provider.umount_fs()
       end
 
       it "should not umount the filesystem if it is not mounted" do
         @current_resource.mounted(false)
-        @provider.should_not_receive(:shell_out!)
+        expect(@provider).not_to receive(:shell_out!)
         @provider.umount_fs()
       end
     end
@@ -347,7 +343,7 @@ describe Chef::Provider::Mount::Mount do
       it "should use mount -o remount if remount is supported" do
         @new_resource.supports({:remount => true})
         @current_resource.mounted(true)
-        @provider.should_receive(:shell_out!).with("mount -o remount,defaults #{@new_resource.mount_point}")
+        expect(@provider).to receive(:shell_out!).with("mount -o remount,defaults #{@new_resource.mount_point}")
         @provider.remount_fs
       end
 
@@ -356,24 +352,24 @@ describe Chef::Provider::Mount::Mount do
         options = "rw,noexec,noauto"
         @new_resource.options(%w{rw noexec noauto})
         @current_resource.mounted(true)
-        @provider.should_receive(:shell_out!).with("mount -o remount,rw,noexec,noauto #{@new_resource.mount_point}")
+        expect(@provider).to receive(:shell_out!).with("mount -o remount,rw,noexec,noauto #{@new_resource.mount_point}")
         @provider.remount_fs
       end
 
       it "should umount and mount if remount is not supported" do
         @new_resource.supports({:remount => false})
         @current_resource.mounted(true)
-        @provider.should_receive(:umount_fs)
-        @provider.should_receive(:sleep).with(1)
-        @provider.should_receive(:mount_fs)
+        expect(@provider).to receive(:umount_fs)
+        expect(@provider).to receive(:sleep).with(1)
+        expect(@provider).to receive(:mount_fs)
         @provider.remount_fs()
       end
 
       it "should not try to remount at all if mounted is false" do
         @current_resource.mounted(false)
-        @provider.should_not_receive(:shell_out!)
-        @provider.should_not_receive(:umount_fs)
-        @provider.should_not_receive(:mount_fs)
+        expect(@provider).not_to receive(:shell_out!)
+        expect(@provider).not_to receive(:umount_fs)
+        expect(@provider).not_to receive(:mount_fs)
         @provider.remount_fs()
       end
     end
@@ -383,9 +379,9 @@ describe Chef::Provider::Mount::Mount do
         @current_resource.enabled(false)
 
         @fstab = StringIO.new
-        ::File.stub(:open).with("/etc/fstab", "a").and_yield(@fstab)
+        allow(::File).to receive(:open).with("/etc/fstab", "a").and_yield(@fstab)
         @provider.enable_fs
-        @fstab.string.should match(%r{^/dev/sdz1\s+/tmp/foo\s+ext3\s+defaults\s+0\s+2\s*$})
+        expect(@fstab.string).to match(%r{^/dev/sdz1\s+/tmp/foo\s+ext3\s+defaults\s+0\s+2\s*$})
       end
 
       it "should not enable if enabled is true and resources match" do
@@ -394,7 +390,7 @@ describe Chef::Provider::Mount::Mount do
         @current_resource.options(["defaults"])
         @current_resource.dump(0)
         @current_resource.pass(2)
-        ::File.should_not_receive(:open).with("/etc/fstab", "a")
+        expect(::File).not_to receive(:open).with("/etc/fstab", "a")
 
         @provider.enable_fs
       end
@@ -406,9 +402,9 @@ describe Chef::Provider::Mount::Mount do
         @current_resource.dump(0)
         @current_resource.pass(2)
         @fstab = StringIO.new
-        ::File.stub(:readlines).and_return([])
-        ::File.should_receive(:open).once.with("/etc/fstab", "w").and_yield(@fstab)
-        ::File.should_receive(:open).once.with("/etc/fstab", "a").and_yield(@fstab)
+        allow(::File).to receive(:readlines).and_return([])
+        expect(::File).to receive(:open).once.with("/etc/fstab", "w").and_yield(@fstab)
+        expect(::File).to receive(:open).once.with("/etc/fstab", "a").and_yield(@fstab)
 
         @provider.enable_fs
       end
@@ -422,13 +418,13 @@ describe Chef::Provider::Mount::Mount do
         this_mount = "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n"
 
         @fstab_read = [this_mount, other_mount]
-        ::File.stub(:readlines).with("/etc/fstab").and_return(@fstab_read)
+        allow(::File).to receive(:readlines).with("/etc/fstab").and_return(@fstab_read)
         @fstab_write = StringIO.new
-        ::File.stub(:open).with("/etc/fstab", "w").and_yield(@fstab_write)
+        allow(::File).to receive(:open).with("/etc/fstab", "w").and_yield(@fstab_write)
 
         @provider.disable_fs
-        @fstab_write.string.should match(Regexp.escape(other_mount))
-        @fstab_write.string.should_not match(Regexp.escape(this_mount))
+        expect(@fstab_write.string).to match(Regexp.escape(other_mount))
+        expect(@fstab_write.string).not_to match(Regexp.escape(this_mount))
       end
 
       it "should disable if enabled is true and ignore commented lines" do
@@ -439,37 +435,37 @@ describe Chef::Provider::Mount::Mount do
                       %q{#/dev/sdz1 /tmp/foo  ext3  defaults  1 2}]
         fstab_write = StringIO.new
 
-        ::File.stub(:readlines).with("/etc/fstab").and_return(fstab_read)
-        ::File.stub(:open).with("/etc/fstab", "w").and_yield(fstab_write)
+        allow(::File).to receive(:readlines).with("/etc/fstab").and_return(fstab_read)
+        allow(::File).to receive(:open).with("/etc/fstab", "w").and_yield(fstab_write)
 
         @provider.disable_fs
-        fstab_write.string.should match(%r{^/dev/sdy1 /tmp/foo  ext3  defaults  1 2$})
-        fstab_write.string.should match(%r{^#/dev/sdz1 /tmp/foo  ext3  defaults  1 2$})
-        fstab_write.string.should_not match(%r{^/dev/sdz1 /tmp/foo  ext3  defaults  1 2$})
+        expect(fstab_write.string).to match(%r{^/dev/sdy1 /tmp/foo  ext3  defaults  1 2$})
+        expect(fstab_write.string).to match(%r{^#/dev/sdz1 /tmp/foo  ext3  defaults  1 2$})
+        expect(fstab_write.string).not_to match(%r{^/dev/sdz1 /tmp/foo  ext3  defaults  1 2$})
       end
 
       it "should disable only the last entry if enabled is true" do
-        @current_resource.stub(:enabled).and_return(true)
+        allow(@current_resource).to receive(:enabled).and_return(true)
         fstab_read = ["/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n",
                       "/dev/sdy1 /tmp/foo  ext3  defaults  1 2\n",
                       "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n",
                       "/dev/sdz1 /tmp/foobar  ext3  defaults  1 2\n"]
 
         fstab_write = StringIO.new
-        ::File.stub(:readlines).with("/etc/fstab").and_return(fstab_read)
-        ::File.stub(:open).with("/etc/fstab", "w").and_yield(fstab_write)
+        allow(::File).to receive(:readlines).with("/etc/fstab").and_return(fstab_read)
+        allow(::File).to receive(:open).with("/etc/fstab", "w").and_yield(fstab_write)
 
         @provider.disable_fs
-        fstab_write.string.should == "/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n" +
+        expect(fstab_write.string).to eq("/dev/sdz1 /tmp/foo  ext3  defaults  1 2\n" +
           "/dev/sdy1 /tmp/foo  ext3  defaults  1 2\n" +
-          "/dev/sdz1 /tmp/foobar  ext3  defaults  1 2\n"
+          "/dev/sdz1 /tmp/foobar  ext3  defaults  1 2\n")
       end
 
       it "should not disable if enabled is false" do
-        @current_resource.stub(:enabled).and_return(false)
+        allow(@current_resource).to receive(:enabled).and_return(false)
 
-        ::File.stub(:readlines).with("/etc/fstab").and_return([])
-        ::File.should_not_receive(:open).and_yield(@fstab)
+        allow(::File).to receive(:readlines).with("/etc/fstab").and_return([])
+        expect(::File).not_to receive(:open).and_yield(@fstab)
 
         @provider.disable_fs
       end