chef 16.1.16 → 16.18.30

data/spec/support/shared/integration/knife_support.rb

@@ -39,10 +39,7 @@ module KnifeSupport
 
     # Work on machines where we can't access /var
     Dir.mktmpdir("checksums") do |checksums_cache_dir|
-      Chef::Config[:cache_options] = {
-        path: checksums_cache_dir,
-        skip_expires: true,
-      }
+      Chef::Config[:syntax_check_cache_path] = checksums_cache_dir
 
       # This is Chef::Knife.run without load_commands--we'll load stuff
       # ourselves, thank you very much
@@ -55,8 +52,6 @@ module KnifeSupport
                 STDIN
               end
 
-      old_loggers = Chef::Log.loggers
-      old_log_level = Chef::Log.level
       begin
         puts "knife: #{args.join(" ")}" if DEBUG
         subcommand_class = Chef::Knife.subcommand_class_from(args)
@@ -115,9 +110,7 @@ module KnifeSupport
       rescue SystemExit => e
         exit_code = e.status
       ensure
-        Chef::Log.use_log_devices(old_loggers)
-        Chef::Log.level = old_log_level
-        Chef::Config.delete(:cache_options)
+        Chef::Config.delete(:syntax_check_cache_path)
         Chef::Config.delete(:concurrency)
       end
 

data/spec/support/shared/unit/application_dot_d.rb

@@ -33,15 +33,16 @@ shared_examples_for "an application that loads a dot d" do
     # make sure that we are correctly globbing.
     let(:client_d_dir) do
       Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../../data/client.d_00")
+        File.join(__dir__, "../../../data/client.d_00")
       )
     end
 
     it "loads the configuration in order" do
+      etc_chef_client_rb = Chef::Config.platform_specific_path("#{ChefConfig::Config.etc_chef_dir}/client.rb")
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_return("foo 0")
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/01-bar.rb").cleanpath.to_s).and_return("bar 0")
       expect(IO).to receive(:read).with(Pathname.new("#{client_d_dir}/02-strings.rb").cleanpath.to_s).and_return("strings 0")
-      allow(app).to receive(:apply_config).with(anything, Chef::Config.platform_specific_path("/etc/chef/client.rb")).and_call_original.ordered
+      allow(app).to receive(:apply_config).with("", etc_chef_client_rb) # for chef-client managed nodes running this spec
       expect(app).to receive(:apply_config).with("foo 0", Pathname.new("#{client_d_dir}/00-foo.rb").cleanpath.to_s).and_call_original.ordered
       expect(app).to receive(:apply_config).with("bar 0", Pathname.new("#{client_d_dir}/01-bar.rb").cleanpath.to_s).and_call_original.ordered
       expect(app).to receive(:apply_config).with("strings 0", Pathname.new("#{client_d_dir}/02-strings.rb").cleanpath.to_s).and_call_original.ordered
@@ -52,7 +53,7 @@ shared_examples_for "an application that loads a dot d" do
   context "when client_d_dir is set to a directory without configuration" do
     let(:client_d_dir) do
       Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../data/client.d_01")
+        File.join(__dir__, "../../data/client.d_01")
       )
     end
 
@@ -70,7 +71,7 @@ shared_examples_for "an application that loads a dot d" do
     # foo.rb as a directory should be ignored
     let(:client_d_dir) do
       Chef::Util::PathHelper.cleanpath(
-        File.join(File.dirname(__FILE__), "../../data/client.d_02")
+        File.join(__dir__, "../../data/client.d_02")
       )
     end
 

data/spec/support/shared/unit/execute_resource.rb

@@ -75,7 +75,7 @@ shared_examples_for "an execute resource" do
   end
 
   it "the old path property (that never worked) is not supported in chef >= 13" do
-    expect { @resource.path [ "woot" ] }.to raise_error
+    expect(@resource).not_to respond_to(:path)
   end
 
   it "should accept an integer for the return code" do

data/spec/support/shared/unit/knife_shared.rb

@@ -33,7 +33,7 @@ shared_examples_for "mandatory field missing" do
 
     it "prints a relevant error message" do
       expect { knife.run }.to raise_error(SystemExit)
-      expect(stderr.string).to match /You must specify a #{fieldname}/
+      expect(stderr.string).to match(/You must specify a #{fieldname}/)
     end
   end
 end

data/spec/support/shared/unit/provider/file.rb

@@ -479,24 +479,42 @@ shared_examples_for Chef::Provider::File do
         it "calls #verify on each verification with tempfile path" do
           provider.new_resource.verify windows? ? "REM" : "true"
           provider.new_resource.verify windows? ? "REM" : "true"
+          allow(provider).to receive(:contents_changed?).and_return(true)
           provider.send(:do_validate_content)
         end
 
         it "raises an exception if any verification fails" do
           allow(File).to receive(:directory?).with("C:\\Windows\\system32/cmd.exe").and_return(false)
-          provider.new_resource.verify windows? ? "REM" : "true"
-          provider.new_resource.verify windows? ? "cmd.exe /c exit 1" : "false"
-          msg = "Proposed content for #{provider.new_resource.path} failed verification #{windows? ? "cmd.exe /c exit 1" : "false"}"
-          expect { provider.send(:do_validate_content) }.to raise_error(Chef::Exceptions::ValidationFailed, /#{msg}/)
+          allow(provider).to receive(:tempfile).and_return(tempfile)
+          allow(provider).to receive(:contents_changed?).and_return(true)
+          provider.new_resource.verify windows? ? "cmd.exe c exit 1" : "false"
+          provider.new_resource.verify.each do |v|
+            allow(v).to receive(:verify).and_return(false)
+          end
+          expect { provider.send(:do_validate_content) }.to raise_error(Chef::Exceptions::ValidationFailed)
+        end
+
+        it "does not run verifications when the contents did not change" do
+          allow(File).to receive(:directory?).with("C:\\Windows\\system32/cmd.exe").and_return(false)
+          allow(provider).to receive(:tempfile).and_return(tempfile)
+          allow(provider).to receive(:contents_changed?).and_return(false)
+          provider.new_resource.verify windows? ? "cmd.exe c exit 1" : "false"
+          provider.new_resource.verify.each do |v|
+            expect(v).not_to receive(:verify)
+          end
+          provider.send(:do_validate_content)
         end
 
         it "does not show verification for sensitive resources" do
           allow(File).to receive(:directory?).with("C:\\Windows\\system32/cmd.exe").and_return(false)
-          provider.new_resource.verify windows? ? "REM" : "true"
-          provider.new_resource.verify windows? ? "cmd.exe /c exit 1" : "false"
+          allow(provider).to receive(:tempfile).and_return(tempfile)
+          allow(provider).to receive(:contents_changed?).and_return(true)
           provider.new_resource.sensitive true
-          msg = "Proposed content for #{provider.new_resource.path} failed verification [sensitive]\nTemporary file moved to #{backupfile}"
-          expect { provider.send(:do_validate_content) }.to raise_error(Chef::Exceptions::ValidationFailed, msg)
+          provider.new_resource.verify windows? ? "cmd.exe c exit 1" : "false"
+          provider.new_resource.verify.each do |v|
+            allow(v).to receive(:verify).and_return(false)
+          end
+          expect { provider.send(:do_validate_content) }.to raise_error(Chef::Exceptions::ValidationFailed, /sensitive/)
         end
       end
     end

data/spec/support/shared/unit/script_resource.rb

@@ -47,42 +47,28 @@ shared_examples_for "a script resource" do
   end
 
   describe "when executing guards" do
-    let(:resource) do
-      resource = script_resource
-      resource.run_context = run_context
-      resource.code "echo hi"
-      resource
-    end
-    let(:node) do
-      node = Chef::Node.new
-      node.automatic[:platform] = "debian"
-      node.automatic[:platform_version] = "6.0"
-      node
-    end
-    let(:events) { Chef::EventDispatch::Dispatcher.new }
-    let(:run_context) { Chef::RunContext.new(node, {}, events) }
-
-    it "inherits exactly the :cwd, :environment, :group, :path, :user, and :umask attributes from a parent resource class" do
+    it "inherits exactly the :cwd, :domain, :environment, :group, :password, :path, :user, and :umask attributes from a parent resource class" do
       inherited_difference = Chef::Resource::Script.guard_inherited_attributes -
-        %i{cwd environment group path user umask}
+        %i{cwd domain environment group password path user umask}
 
       expect(inherited_difference).to eq([])
     end
 
     it "when guard_interpreter is set to the default value, the guard command string should be evaluated by command execution and not through a resource" do
       expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate_block)
-      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).not_to receive(:evaluate_action)
+      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).not_to receive(:evaluate)
       expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:evaluate).and_return(true)
-      resource.only_if "echo hi"
-      expect(resource.should_skip?(:run)).to eq(nil)
+      script_resource.only_if "echo hi"
+      expect(script_resource.should_skip?(:run)).to eq(nil)
     end
 
     it "when a valid guard_interpreter resource is specified, a block should be used to evaluate the guard" do
+      expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate_block)
       expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
-      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
-      resource.guard_interpreter :script
-      resource.only_if "echo hi"
-      expect(resource.should_skip?(:run)).to eq(nil)
+      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate).and_return(true)
+      script_resource.guard_interpreter :script
+      script_resource.only_if "echo hi"
+      expect(script_resource.should_skip?(:run)).to eq(nil)
     end
   end
 end

data/spec/support/shared/unit/windows_script_resource.rb

@@ -20,59 +20,46 @@ require "support/shared/unit/execute_resource"
 require "support/shared/unit/script_resource"
 
 shared_examples_for "a Windows script resource" do
-  before(:each) do
-    node = Chef::Node.new
-
-    node.default["kernel"] = {}
-    node.default["kernel"][:machine] = :x86_64.to_s
-
-    run_context = Chef::RunContext.new(node, nil, nil)
-
-    @resource = resource_instance
-
-  end
-
   it "should be a kind of Chef::Resource::WindowsScript" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::WindowsScript)
+    expect(windows_script_resource).to be_a_kind_of(Chef::Resource)
+    expect(windows_script_resource).to be_a_kind_of(Chef::Resource::WindowsScript)
   end
 
   context "when evaluating guards" do
     it "should have a default_guard_interpreter attribute that is the same as the resource" do
-      expect(@resource.default_guard_interpreter).to eq(@resource.resource_name)
+      expect(windows_script_resource.default_guard_interpreter).to eq(windows_script_resource.resource_name)
     end
 
     it "should default to using guard_interpreter attribute that is the same as the resource" do
-      expect(@resource.guard_interpreter).to eq(@resource.resource_name)
+      expect(windows_script_resource.guard_interpreter).to eq(windows_script_resource.resource_name)
     end
 
     it "should use a resource to evaluate the guard when guard_interpreter is not specified" do
-      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
+      expect_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate).and_return(true)
       expect_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:evaluate)
-      @resource.only_if "echo hi"
-      expect(@resource.should_skip?(:run)).to eq(nil)
+      windows_script_resource.only_if "echo hi"
+      expect(windows_script_resource.should_skip?(:run)).to eq(nil)
     end
 
     describe "when the guard is given a ruby block" do
       it "should evaluate the guard if the guard_interpreter is set to its default value" do
-        @resource.only_if { true }
-        expect(@resource.should_skip?(:run)).to eq(nil)
+        windows_script_resource.only_if { true }
+        expect(windows_script_resource.should_skip?(:run)).to eq(nil)
       end
 
       it "should raise an exception if the guard_interpreter is overridden from its default value" do
-        @resource.guard_interpreter :bash
-        @resource.only_if { true }
-        expect { @resource.should_skip?(:run) }.to raise_error(ArgumentError)
+        windows_script_resource.guard_interpreter :bash
+        windows_script_resource.only_if { true }
+        expect { windows_script_resource.should_skip?(:run) }.to raise_error(ArgumentError)
       end
     end
   end
 
   context "script with a default guard interpreter" do
-    let(:script_resource) do
-      resource_instance.guard_interpreter :default
-      resource_instance
-    end
+    let(:script_resource) { windows_script_resource }
+
+    before { windows_script_resource.guard_interpreter :default }
+
     it_should_behave_like "a script resource"
   end
-
 end

data/spec/tiny_server.rb

@@ -19,7 +19,6 @@
 require "webrick"
 require "webrick/https"
 require "rack"
-require "thread"
 require "singleton"
 require "open-uri"
 require "chef/config"

data/spec/unit/application/client_spec.rb

@@ -192,7 +192,7 @@ describe Chef::Application::Client, "reconfigure" do
 
       context "with an empty value" do
         it "should terminate with message" do
-          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option ""').and_raise("so ded")
+          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option ""', ChefConfig::ConfigurationError.new).and_raise("so ded")
           ARGV.replace(["--config-option", ""])
           expect { app.reconfigure }.to raise_error "so ded"
         end
@@ -200,7 +200,7 @@ describe Chef::Application::Client, "reconfigure" do
 
       context "with an invalid value" do
         it "should terminate with message" do
-          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option "asdf"').and_raise("so ded")
+          expect(Chef::Application).to receive(:fatal!).with('Unparsable config option "asdf"', ChefConfig::ConfigurationError.new).and_raise("so ded")
           ARGV.replace(["--config-option", "asdf"])
           expect { app.reconfigure }.to raise_error "so ded"
         end

data/spec/unit/application/exit_code_spec.rb

@@ -61,6 +61,10 @@ describe Chef::Application::ExitCode do
       expect(valid_rfc_exit_codes.include?(41)).to eq(true)
     end
 
+    it "validates a CONFIG_FAILURE return code of 43" do
+      expect(valid_rfc_exit_codes.include?(43)).to eq(true)
+    end
+
     it "validates a CLIENT_UPGRADED return code of 213" do
       expect(valid_rfc_exit_codes.include?(213)).to eq(true)
     end
@@ -113,6 +117,12 @@ describe Chef::Application::ExitCode do
       expect(exit_codes.normalize_exit_code(runtime_error)).to eq(37)
     end
 
+    it "returns CONFIG_FAILURE when a configuration exception is specified" do
+      config_error = Chef::Exceptions::ConfigurationError.new("BOOM")
+      runtime_error = Chef::Exceptions::RunFailedWrappingError.new(config_error)
+      expect(exit_codes.normalize_exit_code(runtime_error)).to eq(43)
+    end
+
     it "returns CLIENT_UPGRADED when the client was upgraded during converge" do
       client_upgraded_error = Chef::Exceptions::ClientUpgraded.new("BOOM")
       runtime_error = Chef::Exceptions::RunFailedWrappingError.new(client_upgraded_error)

data/spec/unit/application/solo_spec.rb

@@ -164,6 +164,8 @@ describe Chef::Application::Solo do
   end
 
   context "in local mode" do
+    let(:root_path) { windows? ? "C:/var/chef" : "/var/chef" }
+
     before do
       Chef::Config[:solo_legacy_mode] = false
     end
@@ -197,10 +199,10 @@ describe Chef::Application::Solo do
     end
 
     it "sets the repo path" do
-      expect(Chef::Config).to receive(:find_chef_repo_path).and_return("/var/chef")
+      expect(Chef::Config).to receive(:find_chef_repo_path).and_return(root_path)
       app.reconfigure
       expect(Chef::Config.key?(:chef_repo_path)).to be_truthy
-      expect(Chef::Config[:chef_repo_path]).to eq ("/var/chef")
+      expect(Chef::Config[:chef_repo_path]).to eq (root_path)
     end
 
     it "runs chef-client in local mode" do

data/spec/unit/application_spec.rb

@@ -22,12 +22,10 @@ describe Chef::Application do
   before do
     @original_argv = ARGV.dup
     ARGV.clear
-    Chef::Log.logger = Logger.new(StringIO.new)
     @app = Chef::Application.new
     allow(@app).to receive(:trap)
     allow(Dir).to receive(:chdir).and_return(0)
     allow(@app).to receive(:reconfigure)
-    Chef::Log.init(STDERR)
   end
 
   after do
@@ -94,6 +92,13 @@ describe Chef::Application do
           end
         end
 
+        describe "when enforce_license is set to false" do
+          it "should not check the license acceptance" do
+            expect(@app).to_not receive(:check_license_acceptance)
+            @app.run(enforce_license: false)
+          end
+        end
+
         it "should run the actual application" do
           expect(@app).to receive(:run_application).and_return(true)
           @app.run
@@ -247,6 +252,10 @@ describe Chef::Application do
       end
 
       context "when log_level is not set" do
+        before do
+          Chef::Config.delete(:log_level)
+        end
+
         it_behaves_like "log_level_is_auto"
       end
 
@@ -482,16 +491,14 @@ describe Chef::Application do
 
   describe "configuration errors" do
     before do
-      expect(Process).to receive(:exit)
+      allow(Process).to receive(:exit).and_return(true)
     end
 
     def raises_informative_fatals_on_configure_chef
       config_file_regexp = Regexp.new @app.config[:config_file]
-      expect(Chef::Log).to receive(:fatal)
-        .with(/Configuration error/)
-      expect(Chef::Log).to receive(:fatal)
-        .with(config_file_regexp)
-        .at_least(1).times
+      expect(Chef::Log).to receive(:fatal).with(/Configuration error/)
+      expect(Chef::Log).to receive(:fatal).with(config_file_regexp)
+      expect(Process).to receive(:exit).with(43).and_return(true)
       @app.configure_chef
     end
 

data/spec/unit/chef_fs/config_spec.rb

@@ -18,7 +18,7 @@
 
 require "spec_helper"
 require "chef/exceptions"
-require "lib/chef/chef_fs/config.rb"
+require "lib/chef/chef_fs/config"
 
 describe Chef::ChefFS::Config do
   describe "initialize" do
@@ -203,8 +203,8 @@ describe Chef::ChefFS::Config do
         })
       end
 
-      let (:path) { "/roles/foo.json" }
-      let (:entry) { Entry.new(path) }
+      let(:path) { "/roles/foo.json" }
+      let(:entry) { Entry.new(path) }
 
       it "returns the entry's path if the cwd isn't in the config" do
         cfg = Chef::ChefFS::Config.new(config, "/my_repo/cookbooks")

data/spec/unit/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -17,7 +17,7 @@
 #
 
 require "spec_helper"
-require "lib/chef/chef_fs/data_handler/data_bag_item_data_handler.rb"
+require "lib/chef/chef_fs/data_handler/data_bag_item_data_handler"
 
 class TestDataBag < Mash
   attr_accessor :name

data/spec/unit/chef_fs/diff_spec.rb

@@ -20,17 +20,17 @@ require "spec_helper"
 require "chef/chef_fs/file_pattern"
 require "chef/chef_fs/command_line"
 
-# Removes the date stamp from the diff and replaces it with ' DATE'
-# example match: "/dev/null\t2012-10-16 16:15:54.000000000 +0000"
-# windows match: "--- /dev/null\tTue Oct 16 18:04:34 2012"
-def remove_os_differences(diff)
-  diff = diff.gsub(/([+-]{3}.*)\t.*/, '\1 DATE')
-  diff.gsub(/^@@ -\d(,\d)? \+\d(,\d)? @@/, "CONTEXT_LINE_NUMBERS")
-end
-
 describe "diff", uses_diff: true do
   include FileSystemSupport
 
+  # Removes the date stamp from the diff and replaces it with ' DATE'
+  # example match: "/dev/null\t2012-10-16 16:15:54.000000000 +0000"
+  # windows match: "--- /dev/null\tTue Oct 16 18:04:34 2012"
+  def remove_os_differences(diff)
+    diff = diff.gsub(/([+-]{3}.*)\t.*/, '\1 DATE')
+    diff.gsub(/^@@ -\d(,\d)? \+\d(,\d)? @@/, "CONTEXT_LINE_NUMBERS")
+  end
+
   context "with two filesystems with all types of difference" do
     let(:a) do
       memory_fs("a", {

data/spec/unit/chef_fs/file_system/operation_failed_error_spec.rb

@@ -25,11 +25,9 @@ describe Chef::ChefFS::FileSystem::OperationFailedError do
 
     context "has a cause attribute and HTTP result code is 400" do
       it "include error cause" do
-        allow_message_expectations_on_nil
         response_body = '{"error":["Invalid key test in request body"]}'
-        allow(@response).to receive(:code).and_return("400")
-        allow(@response).to receive(:body).and_return(response_body)
-        exception = Net::HTTPClientException.new("(exception) unauthorized", @response)
+        response = double(:response, code: "400", body: response_body)
+        exception = Net::HTTPClientException.new("(exception) unauthorized", response)
         expect do
           raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, exception), error_message
         end.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, "#{error_message} cause: #{response_body}")

data/spec/unit/chef_fs/{parallelizer.rb → parallelizer_spec.rb}

@@ -1,7 +1,11 @@
 require "spec_helper"
 require "chef/chef_fs/parallelizer"
 
-describe Chef::ChefFS::Parallelizer do
+# FIXME: these are disabled on MacOS due to timing issues in our anka build cluster
+# these issues should be fixed and the tests should be re-eenabled.  If we are getting
+# omnibus test phases on mac tests which are reasonable and not ~3 hours long, then the
+# condition to avoid this testing on macs can be deleted
+describe Chef::ChefFS::Parallelizer, :not_supported_on_macos do
   before :each do
     @start_time = Time.now
   end
@@ -405,7 +409,7 @@ describe Chef::ChefFS::Parallelizer do
         expect do
           b = enum.enum_for(:each)
           b.next
-        end.to raise_error
+        end.to raise_error(RuntimeError, "each() called on parallel enumerable twice simultaneously! Bad mojo")
       end
     end
   end

data/spec/unit/chef_fs/path_util_spec.rb

@@ -61,7 +61,7 @@ describe Chef::ChefFS::PathUtils do
   end
 
   context "invoking realest_path" do
-    let(:good_path) { File.dirname(__FILE__) }
+    let(:good_path) { __dir__ }
     let(:parent_path) { File.dirname(good_path) }
 
     it "handles paths with no wildcards or globs" do

data/spec/unit/client_spec.rb

@@ -129,6 +129,7 @@ shared_context "a client run" do
     expect(client.events).to receive(:register).with(instance_of(Chef::DataCollector::Reporter))
     expect(client.events).to receive(:register).with(instance_of(Chef::ResourceReporter))
     expect(client.events).to receive(:register).with(instance_of(Chef::ActionCollection))
+    expect(client.events).to receive(:register).with(instance_of(Chef::Compliance::Runner))
   end
 
   def stub_for_node_load
@@ -309,14 +310,14 @@ describe Chef::Client do
 
   describe "eol release warning" do
     it "warns when running an EOL release" do
-      stub_const("Chef::VERSION", 15)
-      allow(Time).to receive(:now).and_return(Time.new(2021, 5, 1, 5))
-      expect(logger).to receive(:warn).with(/This release of.*became end of life \(EOL\) on May 1st 2021/)
+      stub_const("Chef::VERSION", 16)
+      allow(Time).to receive(:now).and_return(Time.new(2022, 11, 30, 5))
+      expect(logger).to receive(:warn).with("This release of #{ChefUtils::Dist::Infra::PRODUCT} became end of life (EOL) on November 30th 2022. Please update to a supported release to receive new features, bug fixes, and security updates.")
       client.warn_if_eol
     end
 
     it "does not warn when running an non-EOL release" do
-      stub_const("Chef::VERSION", 15)
+      stub_const("Chef::VERSION", 16)
       allow(Time).to receive(:now).and_return(Time.new(2021, 4, 31))
       expect(logger).to_not receive(:warn).with(/became end of life/)
       client.warn_if_eol
@@ -749,9 +750,12 @@ describe Chef::Client do
 
     context "when any directory of cookbook_path contains no cookbook" do
       it "raises CookbookNotFound error" do
+        invalid_cookbook_path = windows? ? "C:/path/to/invalid/cookbook_path" : "/path/to/invalid/cookbook_path"
+        msg = "None of the cookbook paths set in Chef::Config[:cookbook_path], [\"#{invalid_cookbook_path}\"], contain any cookbooks"
+
         expect do
           client.send(:assert_cookbook_path_not_empty, nil)
-        end.to raise_error(Chef::Exceptions::CookbookNotFound, 'None of the cookbook paths set in Chef::Config[:cookbook_path], ["/path/to/invalid/cookbook_path"], contain any cookbooks')
+        end.to raise_error(Chef::Exceptions::CookbookNotFound, msg)
       end
     end
   end
@@ -798,4 +802,20 @@ describe Chef::Client do
       allow_any_instance_of(Chef::RunLock).to receive(:save_pid).and_raise(NoMethodError)
     end
   end
+
+  describe "deprecated enforce_path_sanity" do
+    include_context "a client run"
+    include_context "converge completed"
+
+    it "print a warning, when enforce_path_sanity is passed" do
+      Chef::Config[:enforce_path_sanity] = true
+      expect(logger).to receive(:warn).with("`enforce_path_sanity` is deprecated, please use `enforce_default_paths` instead!")
+      client.run
+    end
+
+    it "should not print a warning, when enforce_path_sanity is not passed" do
+      expect(logger).not_to receive(:warn).with("`enforce_path_sanity` is deprecated, please use `enforce_default_paths` instead!")
+      client.run
+    end
+  end
 end