chef 12.0.3 → 12.1.0.rc.0

data/spec/unit/data_bag_spec.rb

@@ -22,36 +22,36 @@ require 'chef/data_bag'
 describe Chef::DataBag do
   before(:each) do
     @data_bag = Chef::DataBag.new
-    Chef::Platform::stub(:windows?) { false }
+    allow(Chef::Platform)::to receive(:windows?) { false }
   end
 
   describe "initialize" do
     it "should be a Chef::DataBag" do
-      @data_bag.should be_a_kind_of(Chef::DataBag)
+      expect(@data_bag).to be_a_kind_of(Chef::DataBag)
     end
   end
 
   describe "name" do
     it "should let you set the name to a string" do
-      @data_bag.name("clowns").should == "clowns"
+      expect(@data_bag.name("clowns")).to eq("clowns")
     end
 
     it "should return the current name" do
       @data_bag.name "clowns"
-      @data_bag.name.should == "clowns"
+      expect(@data_bag.name).to eq("clowns")
     end
 
     it "should not accept spaces" do
-      lambda { @data_bag.name "clown masters" }.should raise_error(ArgumentError)
+      expect { @data_bag.name "clown masters" }.to raise_error(ArgumentError)
     end
 
     it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @data_bag.name Hash.new }.should raise_error(ArgumentError)
+      expect { @data_bag.name Hash.new }.to raise_error(ArgumentError)
     end
 
     [ ".", "-", "_", "1"].each do |char|
       it "should allow a '#{char}' character in the data bag name" do
-        @data_bag.name("clown#{char}clown").should == "clown#{char}clown"
+        expect(@data_bag.name("clown#{char}clown")).to eq("clown#{char}clown")
       end
     end
   end
@@ -63,14 +63,14 @@ describe Chef::DataBag do
     end
 
     it "should deserialize to a Chef::DataBag object" do
-      @deserial.should be_a_kind_of(Chef::DataBag)
+      expect(@deserial).to be_a_kind_of(Chef::DataBag)
     end
 
     %w{
       name
     }.each do |t|
       it "should match '#{t}'" do
-        @deserial.send(t.to_sym).should == @data_bag.send(t.to_sym)
+        expect(@deserial.send(t.to_sym)).to eq(@data_bag.send(t.to_sym))
       end
 
       include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
@@ -84,17 +84,17 @@ describe Chef::DataBag do
     before do
       @data_bag.name('piggly_wiggly')
       @rest = double("Chef::REST")
-      Chef::REST.stub(:new).and_return(@rest)
+      allow(Chef::REST).to receive(:new).and_return(@rest)
     end
 
     it "should silently proceed when the data bag already exists" do
       exception = double("409 error", :code => "409")
-      @rest.should_receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
+      expect(@rest).to receive(:post_rest).and_raise(Net::HTTPServerException.new("foo", exception))
       @data_bag.save
     end
 
     it "should create the data bag" do
-      @rest.should_receive(:post_rest).with("data", @data_bag)
+      expect(@rest).to receive(:post_rest).with("data", @data_bag)
       @data_bag.save
     end
 
@@ -106,7 +106,7 @@ describe Chef::DataBag do
         Chef::Config[:why_run] = false
       end
       it "should not save" do
-        @rest.should_not_receive(:post_rest)
+        expect(@rest).not_to receive(:post_rest)
         @data_bag.save
       end
     end
@@ -120,25 +120,25 @@ describe Chef::DataBag do
       end
 
       it "should get the data bag from the server" do
-        Chef::REST.should_receive(:new).with('https://myserver.example.com').and_return(@http_client)
-        @http_client.should_receive(:get_rest).with('data/foo')
+        expect(Chef::REST).to receive(:new).with('https://myserver.example.com').and_return(@http_client)
+        expect(@http_client).to receive(:get_rest).with('data/foo')
         Chef::DataBag.load('foo')
       end
 
       it "should return the data bag" do
-        Chef::REST.stub(:new).and_return(@http_client)
-        @http_client.should_receive(:get_rest).with('data/foo').and_return({'bar' => 'https://myserver.example.com/data/foo/bar'})
+        allow(Chef::REST).to receive(:new).and_return(@http_client)
+        expect(@http_client).to receive(:get_rest).with('data/foo').and_return({'bar' => 'https://myserver.example.com/data/foo/bar'})
         data_bag = Chef::DataBag.load('foo')
-        data_bag.should == {'bar' => 'https://myserver.example.com/data/foo/bar'}
+        expect(data_bag).to eq({'bar' => 'https://myserver.example.com/data/foo/bar'})
       end
     end
 
     def file_dir_stub(path, returns = true)
-      File.should_receive(:directory?).with(path).and_return(returns)
+      expect(File).to receive(:directory?).with(path).and_return(returns)
     end
 
     def dir_glob_stub(path, returns = [])
-      Dir.should_receive(:glob).with(File.join(path, 'foo/*.json')).and_return(returns)
+      expect(Dir).to receive(:glob).with(File.join(path, 'foo/*.json')).and_return(returns)
     end
 
     shared_examples_for "data bag in solo mode" do |data_bag_path|
@@ -177,21 +177,21 @@ describe Chef::DataBag do
             dir_glob_stub(path)
           end
         end
-        IO.should_receive(:read).with(File.join(@paths.first, 'foo/bar.json')).and_return('{"id": "bar", "name": "Bob Bar" }')
-        IO.should_receive(:read).with(File.join(@paths.first, 'foo/baz.json')).and_return('{"id": "baz", "name": "John Baz" }')
+        expect(IO).to receive(:read).with(File.join(@paths.first, 'foo/bar.json')).and_return('{"id": "bar", "name": "Bob Bar" }')
+        expect(IO).to receive(:read).with(File.join(@paths.first, 'foo/baz.json')).and_return('{"id": "baz", "name": "John Baz" }')
         data_bag = Chef::DataBag.load('foo')
-        data_bag.should == { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { 'id' => 'baz', 'name' => 'John Baz' }}
+        expect(data_bag).to eq({ 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar' }, 'baz' => { 'id' => 'baz', 'name' => 'John Baz' }})
       end
 
       it "should raise if data bag has items with similar names but different content" do
         @paths.each do |path|
           file_dir_stub(path)
           item_with_different_content = "{\"id\": \"bar\", \"name\": \"Bob Bar\", \"path\": \"#{path}\"}"
-          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_different_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_different_content)
           if data_bag_path.is_a?(String)
             dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
             item_2_with_different_content = '{"id": "bar", "name": "John Baz"}'
-            IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_2_with_different_content)
+            expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_2_with_different_content)
           else
             dir_glob_stub(path, [File.join(path, 'foo/bar.json')])
           end
@@ -204,12 +204,12 @@ describe Chef::DataBag do
           file_dir_stub(path)
           dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
           item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
-          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_same_content)
-          IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_with_same_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(item_with_same_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(item_with_same_content)
         end
         data_bag = Chef::DataBag.load('foo')
         test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
-        data_bag.should == test_data_bag
+        expect(data_bag).to eq(test_data_bag)
       end
 
       it "should merge data bag items if there are no conflicts" do
@@ -217,33 +217,33 @@ describe Chef::DataBag do
           file_dir_stub(path)
           dir_glob_stub(path, [File.join(path, 'foo/bar.json'), File.join(path, 'foo/baz.json')])
           test_item_with_same_content = '{"id": "bar", "name": "Bob Bar"}'
-          IO.should_receive(:read).with(File.join(path, 'foo/bar.json')).and_return(test_item_with_same_content)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/bar.json')).and_return(test_item_with_same_content)
           test_uniq_item = "{\"id\": \"baz_#{index}\", \"name\": \"John Baz\", \"path\": \"#{path}\"}"
-          IO.should_receive(:read).with(File.join(path, 'foo/baz.json')).and_return(test_uniq_item)
+          expect(IO).to receive(:read).with(File.join(path, 'foo/baz.json')).and_return(test_uniq_item)
         end
         data_bag = Chef::DataBag.load('foo')
         test_data_bag = { 'bar' => { 'id' => 'bar', 'name' => 'Bob Bar'} }
         @paths.each_with_index do |path, index|
           test_data_bag["baz_#{index}"] = { "id" => "baz_#{index}", "name" => "John Baz", "path" => path }
         end
-        data_bag.should == test_data_bag
+        expect(data_bag).to eq(test_data_bag)
       end
 
       it "should return the data bag list" do
         @paths.each do |path|
           file_dir_stub(path)
-          Dir.should_receive(:glob).and_return([File.join(path, 'foo'), File.join(path, 'bar')])
+          expect(Dir).to receive(:glob).and_return([File.join(path, 'foo'), File.join(path, 'bar')])
         end
         data_bag_list = Chef::DataBag.list
-        data_bag_list.should == { 'bar' => 'bar', 'foo' => 'foo' }
+        expect(data_bag_list).to eq({ 'bar' => 'bar', 'foo' => 'foo' })
       end
 
       it 'should raise an error if the configured data_bag_path is invalid' do
         file_dir_stub(@paths.first, false)
 
-        lambda {
+        expect {
           Chef::DataBag.load('foo')
-        }.should raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
+        }.to raise_error Chef::Exceptions::InvalidDataBagPath, "Data bag path '/var/chef/data_bags' is invalid"
       end
 
     end

data/spec/unit/deprecation_spec.rb

@@ -54,32 +54,45 @@ describe Chef::Deprecation do
 
     it "defines all methods on #{class_object} that were available in 11.0" do
       old_methods.each do |old_method|
-        current_methods.should include(old_method.to_sym)
+        expect(current_methods).to include(old_method.to_sym)
       end
     end
   end
 
-  context 'deprecation warning messages' do
-    before(:each) do
-      @warning_output = [ ]
-      Chef::Log.stub(:warn) { |msg| @warning_output << msg }
+  context 'when Chef::Config[:treat_deprecation_warnings_as_errors] is off' do
+    before do
+      Chef::Config[:treat_deprecation_warnings_as_errors] = false
     end
 
-    it 'should be enabled for deprecated methods' do
-      TestClass.new.deprecated_method(10)
-      @warning_output.should_not be_empty
+    context 'deprecation warning messages' do
+      before(:each) do
+        @warning_output = [ ]
+        allow(Chef::Log).to receive(:warn) { |msg| @warning_output << msg }
+      end
+
+      it 'should be enabled for deprecated methods' do
+        TestClass.new.deprecated_method(10)
+        expect(@warning_output).not_to be_empty
+      end
+
+      it 'should contain stack trace' do
+        TestClass.new.deprecated_method(10)
+        expect(@warning_output.join("").include?(".rb")).to be_truthy
+      end
     end
 
-    it 'should contain stack trace' do
-      TestClass.new.deprecated_method(10)
-      @warning_output.join("").include?(".rb").should be_true
+    it 'deprecated methods should still be called' do
+      test_instance = TestClass.new
+      test_instance.deprecated_method(10)
+      expect(test_instance.get_value).to eq(10)
     end
   end
 
-  it 'deprecated methods should still be called' do
+  it 'should raise when deprecation warnings are treated as errors' do
+    # rspec should set this
+    expect(Chef::Config[:treat_deprecation_warnings_as_errors]).to be true
     test_instance = TestClass.new
-    test_instance.deprecated_method(10)
-    test_instance.get_value.should == 10
+    expect { test_instance.deprecated_method(10) }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
   end
 
 end

data/spec/unit/digester_spec.rb

@@ -28,20 +28,20 @@ describe Chef::Digester do
   describe "when computing checksums of cookbook files and templates" do
 
     it "proxies the class method checksum_for_file to the instance" do
-      @cache.should_receive(:checksum_for_file).with("a_file_or_a_fail")
+      expect(@cache).to receive(:checksum_for_file).with("a_file_or_a_fail")
       Chef::Digester.checksum_for_file("a_file_or_a_fail")
     end
 
     it "computes a checksum of a file" do
       fixture_file = CHEF_SPEC_DATA + "/checksum/random.txt"
       expected = "09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394"
-      @cache.checksum_for_file(fixture_file).should == expected
+      expect(@cache.checksum_for_file(fixture_file)).to eq(expected)
     end
 
     it "generates a checksum from a non-file IO object" do
       io = StringIO.new("riseofthemachines\nriseofthechefs\n")
       expected_md5 = '0e157ac1e2dd73191b76067fb6b4bceb'
-      @cache.generate_md5_checksum(io).should == expected_md5
+      expect(@cache.generate_md5_checksum(io)).to eq(expected_md5)
     end
 
   end

data/spec/unit/dsl/audit_spec.rb

@@ -0,0 +1,43 @@
+
+require 'spec_helper'
+require 'chef/dsl/audit'
+
+class AuditDSLTester < Chef::Recipe
+  include Chef::DSL::Audit
+end
+
+class BadAuditDSLTester
+  include Chef::DSL::Audit
+end
+
+describe Chef::DSL::Audit do
+  let(:auditor) { AuditDSLTester.new("cookbook_name", "recipe_name", run_context) }
+  let(:run_context) { instance_double(Chef::RunContext, :audits => audits, :cookbook_collection => cookbook_collection) }
+  let(:audits) { {} }
+  let(:cookbook_collection) { {} }
+
+  it "raises an error when a block of audits is not provided" do
+    expect{ auditor.control_group "name" }.to raise_error(Chef::Exceptions::NoAuditsProvided)
+  end
+
+  it "raises an error when no audit name is given" do
+    expect{ auditor.control_group do end }.to raise_error(Chef::Exceptions::AuditNameMissing)
+  end
+
+  context "audits already populated" do
+    let(:audits) { {"unique" => {} } }
+
+    it "raises an error if the audit name is a duplicate" do
+      expect { auditor.control_group "unique" do end }.to raise_error(Chef::Exceptions::AuditControlGroupDuplicate)
+    end
+  end
+
+  context "included in a class without recipe DSL" do
+    let(:auditor) { BadAuditDSLTester.new }
+
+    it "fails because it relies on the recipe DSL existing" do
+      expect { auditor.control_group "unique" do end }.to raise_error(NoMethodError, /undefined method `cookbook_name'/)
+    end
+  end
+
+end

data/spec/unit/dsl/data_query_spec.rb

@@ -28,7 +28,7 @@ describe Chef::DSL::DataQuery do
 
   let(:language) do
     language = DataQueryDSLTester.new
-    language.stub(:node).and_return(@node)
+    allow(language).to receive(:node).and_return(@node)
     language
   end
 

data/spec/unit/dsl/platform_introspection_spec.rb

@@ -48,37 +48,37 @@ describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
   end
 
   it "returns the default value when the platform doesn't match" do
-    @platform_specific_value.value_for_node(:platform => :dos).should == 'bork da bork'
+    expect(@platform_specific_value.value_for_node(:platform => :dos)).to eq('bork da bork')
   end
 
   it "returns a value for a platform set as a group" do
-    @platform_specific_value.value_for_node(:platform => :centos).should == '"stable"'
+    expect(@platform_specific_value.value_for_node(:platform => :centos)).to eq('"stable"')
   end
 
   it "returns a value for the platform when it was set as a symbol but fetched as a string" do
-    @platform_specific_value.value_for_node(:platform => "centos").should == '"stable"'
+    expect(@platform_specific_value.value_for_node(:platform => "centos")).to eq('"stable"')
   end
 
   it "returns a value for a specific platform version" do
     node = {:platform => 'ubuntu', :platform_version => '10.04'}
-    @platform_specific_value.value_for_node(node).should == 'using upstart more'
+    expect(@platform_specific_value.value_for_node(node)).to eq('using upstart more')
   end
 
   it "returns a platform-default value if the platform version doesn't match an explicit one" do
     node = {:platform => 'ubuntu', :platform_version => '9.10' }
-    @platform_specific_value.value_for_node(node).should == 'using init more'
+    expect(@platform_specific_value.value_for_node(node)).to eq('using init more')
   end
 
   it "returns nil if there is no default and no platforms match" do
     # this matches the behavior in the original implementation.
     # whether or not it's correct is another matter.
     platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new({})
-    platform_specific_value.value_for_node(:platform => 'foo').should be_nil
+    expect(platform_specific_value.value_for_node(:platform => 'foo')).to be_nil
   end
 
   it "raises an argument error if the platform hash is not correctly structured" do
     bad_hash = {:ubuntu => :foo} # should be :ubuntu => {:default => 'foo'}
-    lambda {Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(bad_hash)}.should raise_error(ArgumentError)
+    expect {Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(bad_hash)}.to raise_error(ArgumentError)
   end
 
 end
@@ -98,33 +98,33 @@ describe Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue do
   end
 
   it "returns the default value when the platform family doesn't match" do
-    @platform_family_value.value_for_node(:platform_family => :os2).should == 'default value'
+    expect(@platform_family_value.value_for_node(:platform_family => :os2)).to eq('default value')
   end
 
 
   it "returns a value for the platform family when it was set as a string but fetched as a symbol" do
-    @platform_family_value.value_for_node(:platform_family => :debian).should == "debian value"
+    expect(@platform_family_value.value_for_node(:platform_family => :debian)).to eq("debian value")
   end
 
   it "returns a value for the platform family when it was set as a symbol but fetched as a string" do
-    @platform_family_value.value_for_node(:platform_family => "gentoo").should == "gentoo value"
+    expect(@platform_family_value.value_for_node(:platform_family => "gentoo")).to eq("gentoo value")
   end
 
   it "returns an array value stored for a platform family" do
-    @platform_family_value.value_for_node(:platform_family => "suse").should == @array_values
+    expect(@platform_family_value.value_for_node(:platform_family => "suse")).to eq(@array_values)
   end
 
   it "returns a value for the platform family when it was set within an array hash key as a symbol" do
-    @platform_family_value.value_for_node(:platform_family => :rhel).should == "redhatty value"
+    expect(@platform_family_value.value_for_node(:platform_family => :rhel)).to eq("redhatty value")
   end
 
   it "returns a value for the platform family when it was set within an array hash key as a string" do
-    @platform_family_value.value_for_node(:platform_family => "fedora").should == "redhatty value"
+    expect(@platform_family_value.value_for_node(:platform_family => "fedora")).to eq("redhatty value")
   end
 
   it "returns nil if there is no default and no platforms match" do
     platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new({})
-    platform_specific_value.value_for_node(:platform_family => 'foo').should be_nil
+    expect(platform_specific_value.value_for_node(:platform_family => 'foo')).to be_nil
   end
 
 end

data/spec/unit/dsl/reboot_pending_spec.rb

@@ -25,52 +25,52 @@ describe Chef::DSL::RebootPending do
       let(:recipe) { Object.new.extend(Chef::DSL::RebootPending) }
 
       before do
-        recipe.stub(:platform?).and_return(false)
+        allow(recipe).to receive(:platform?).and_return(false)
       end
 
       context "platform is windows" do
         before do
-          recipe.stub(:platform?).with('windows').and_return(true)
-          recipe.stub(:registry_key_exists?).and_return(false)
-          recipe.stub(:registry_value_exists?).and_return(false)
+          allow(recipe).to receive(:platform?).with('windows').and_return(true)
+          allow(recipe).to receive(:registry_key_exists?).and_return(false)
+          allow(recipe).to receive(:registry_value_exists?).and_return(false)
         end
   
         it 'should return true if "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations" exists' do
-          recipe.stub(:registry_value_exists?).with('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => 'PendingFileRenameOperations' }).and_return(true)
-          expect(recipe.reboot_pending?).to be_true
+          allow(recipe).to receive(:registry_value_exists?).with('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => 'PendingFileRenameOperations' }).and_return(true)
+          expect(recipe.reboot_pending?).to be_truthy
         end
   
         it 'should return true if "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired" exists' do
-          recipe.stub(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired').and_return(true)
-          expect(recipe.reboot_pending?).to be_true
+          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired').and_return(true)
+          expect(recipe.reboot_pending?).to be_truthy
         end
   
         it 'should return true if key "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired" exists' do
-          recipe.stub(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired').and_return(true)
-          expect(recipe.reboot_pending?).to be_true
+          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired').and_return(true)
+          expect(recipe.reboot_pending?).to be_truthy
         end
   
         it 'should return true if value "HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile" contains specific data' do
-          recipe.stub(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(true)
-          recipe.stub(:registry_get_values).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(
+          allow(recipe).to receive(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(true)
+          allow(recipe).to receive(:registry_get_values).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(
                 [{:name => "Flags", :type => :dword, :data => 3}])
-          expect(recipe.reboot_pending?).to be_true
+          expect(recipe.reboot_pending?).to be_truthy
         end
       end
   
       context "platform is ubuntu" do
         before do
-          recipe.stub(:platform?).with('ubuntu').and_return(true)
+          allow(recipe).to receive(:platform?).with('ubuntu').and_return(true)
         end
   
         it 'should return true if /var/run/reboot-required exists' do
-          File.stub(:exists?).with('/var/run/reboot-required').and_return(true)
-          expect(recipe.reboot_pending?).to be_true
+          allow(File).to receive(:exists?).with('/var/run/reboot-required').and_return(true)
+          expect(recipe.reboot_pending?).to be_truthy
         end
   
         it 'should return false if /var/run/reboot-required does not exist' do
-          File.stub(:exists?).with('/var/run/reboot-required').and_return(false)
-          expect(recipe.reboot_pending?).to be_false
+          allow(File).to receive(:exists?).with('/var/run/reboot-required').and_return(false)
+          expect(recipe.reboot_pending?).to be_falsey
         end
       end