chef 16.3.45-universal-mingw32 → 16.5.77-universal-mingw32

data/spec/unit/data_collector_spec.rb

@@ -26,10 +26,6 @@ require "socket"
 # actually running -- another testing requirement similar to the integration testing framework in cheffish as well)
 #
 describe Chef::DataCollector do
-  before(:each) do
-    Chef::Config[:enable_reporting] = true
-  end
-
   let(:node) { Chef::Node.new }
 
   let(:rest_client) { double("Chef::ServerAPI (mock)") }
@@ -39,6 +35,13 @@ describe Chef::DataCollector do
   let(:new_resource) do
     new_resource = Chef::Resource::File.new("/tmp/a-file.txt")
     new_resource.checksum nil
+    # This next line is a hack to work around the fact that the name property will not have been autovivified yet
+    # in these unit tests which breaks some assumptions.  Really the Formatters::ErrorMapper.resource_failed and
+    # related APIs need to properly walk and get properties on the resource rather than walking through instance
+    # variables, but the ErrorMappers probably pre-date the conversion to properties.  But this next line is necesary
+    # to populate the name_property instance variable (which will happen naturally during the course of running the
+    # provider, so I don't think this is a user-visibile bug).
+    new_resource.path
     new_resource
   end
 
@@ -289,119 +292,6 @@ describe Chef::DataCollector do
     end
   end
 
-  describe "#should_be_enabled?" do
-    shared_examples_for "a solo-like run" do
-      it "is disabled in solo-legacy without a data_collector url and token" do
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-      end
-
-      it "is disabled in solo-legacy with only a url" do
-        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-      end
-
-      it "is disabled in solo-legacy with only a token" do
-        Chef::Config[:data_collector][:token] = "admit_one"
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-      end
-
-      it "is enabled in solo-legacy with both a token and url" do
-        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
-        Chef::Config[:data_collector][:token] = "no_cash_value"
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-      end
-
-      it "is enabled in solo-legacy with only an output location to a file" do
-        Chef::Config[:data_collector][:output_locations] = { files: [ "/always/be/counting/down" ] }
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-      end
-
-      it "is disabled in solo-legacy with only an output location to a uri" do
-        Chef::Config[:data_collector][:output_locations] = { urls: [ "https://esa.local/ariane5" ] }
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-      end
-
-      it "is enabled in solo-legacy with only an output location to a uri with a token" do
-        Chef::Config[:data_collector][:output_locations] = { urls: [ "https://esa.local/ariane5" ] }
-        Chef::Config[:data_collector][:token] = "good_for_one_fare"
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-      end
-
-      it "is enabled in solo-legacy when the mode is :solo" do
-        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
-        Chef::Config[:data_collector][:token] = "non_redeemable"
-        Chef::Config[:data_collector][:mode] = :solo
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-      end
-
-      it "is enabled in solo-legacy when the mode is :both" do
-        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
-        Chef::Config[:data_collector][:token] = "non_negotiable"
-        Chef::Config[:data_collector][:mode] = :both
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-      end
-
-      it "is disabled in solo-legacy when the mode is :client" do
-        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
-        Chef::Config[:data_collector][:token] = "NYCTA"
-        Chef::Config[:data_collector][:mode] = :client
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-      end
-
-      it "is disabled in solo-legacy mode when the mode is :nonsense" do
-        Chef::Config[:data_collector][:server_url] = "https://www.esa.local/ariane5"
-        Chef::Config[:data_collector][:token] = "MTA"
-        Chef::Config[:data_collector][:mode] = :nonsense
-        expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-      end
-    end
-
-    it "by default it is enabled" do
-      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-    end
-
-    it "is disabled in why-run" do
-      Chef::Config[:why_run] = true
-      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-    end
-
-    describe "a solo legacy run" do
-      before(:each) do
-        Chef::Config[:solo_legacy_mode] = true
-      end
-
-      it_behaves_like "a solo-like run"
-    end
-
-    describe "a local mode run" do
-      before(:each) do
-        Chef::Config[:local_mode] = true
-      end
-
-      it_behaves_like "a solo-like run"
-    end
-
-    it "is enabled in client mode when the mode is :both" do
-      Chef::Config[:data_collector][:mode] = :both
-      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-    end
-
-    it "is disabled in client mode when the mode is :solo" do
-      Chef::Config[:data_collector][:mode] = :solo
-      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-    end
-
-    it "is disabled in client mode when the mode is :nonsense" do
-      Chef::Config[:data_collector][:mode] = :nonsense
-      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be false
-    end
-
-    it "is still enabled if you set a token in client mode" do
-      Chef::Config[:data_collector][:token] =  "good_for_one_ride"
-      expect(Chef::DataCollector::ConfigValidation.should_be_enabled?).to be true
-    end
-  end
-
   describe "when the run fails during node load" do
     let(:exception) { Exception.new("imperial to metric conversion error") }
     let(:error_description) { Chef::Formatters::ErrorMapper.registration_failed(node_name, exception, Chef::Config).for_json }
@@ -780,6 +670,13 @@ describe Chef::DataCollector do
         let(:resource_record) do
           rec = resource_record_for(new_resource, current_resource, nil, :create, "failed", "1234")
           rec["error_message"] = "imperial to metric conversion error"
+          rec["error"] = {
+            "class" => exception.class,
+            "message" => exception.message,
+            "backtrace" => exception.backtrace,
+            "description" => error_description,
+          }
+
           [ rec ]
         end
         let(:status) { "failure" }
@@ -808,6 +705,13 @@ describe Chef::DataCollector do
           rec = resource_record_for(new_resource, nil, nil, :create, "failed", "1234")
           rec["before"] = {}
           rec["error_message"] = "imperial to metric conversion error"
+          rec["error"] = {
+            "class" => exception.class,
+            "message" => exception.message,
+            "backtrace" => exception.backtrace,
+            "description" => error_description,
+          }
+
           [ rec ]
         end
         let(:status) { "failure" }
@@ -842,6 +746,13 @@ describe Chef::DataCollector do
         let(:resource_record) do
           rec1 = resource_record_for(new_resource, current_resource, nil, :create, "failed", "1234")
           rec1["error_message"] = "imperial to metric conversion error"
+          rec1["error"] = {
+            "class" => exception.class,
+            "message" => exception.message,
+            "backtrace" => exception.backtrace,
+            "description" => error_description,
+          }
+
           rec2 = resource_record_for(unprocessed_resource, nil, nil, :nothing, "unprocessed", "")
           [ rec1, rec2 ]
         end

data/spec/unit/dsl/declare_resource_spec.rb

@@ -19,7 +19,7 @@ require "spec_helper"
 
 describe Chef::ResourceCollection do
   let(:run_context) do
-    cookbook_repo = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "data", "cookbooks"))
+    cookbook_repo = File.expand_path(File.join(__dir__, "..", "..", "data", "cookbooks"))
     cookbook_loader = Chef::CookbookLoader.new(cookbook_repo)
     cookbook_loader.load_cookbooks
     node = Chef::Node.new

data/spec/unit/environment_spec.rb

@@ -402,8 +402,8 @@ describe Chef::Environment do
 
       it "should get the environment from the environment_path" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
         expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         expect(File).to receive(:file?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         role_dsl = "name \"foo\"\ndescription \"desc\"\n"
@@ -413,7 +413,7 @@ describe Chef::Environment do
 
       it "should return a Chef::Environment object from JSON" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(true)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(true)
         environment_hash = {
           "name" => "foo",
           "default_attributes" => {
@@ -436,8 +436,8 @@ describe Chef::Environment do
 
       it "should return a Chef::Environment object from Ruby DSL" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).exactly(1).times.and_return(true)
         expect(File).to receive(:readable?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         expect(File).to receive(:file?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(true)
         role_dsl = "name \"foo\"\ndescription \"desc\"\n"
@@ -463,8 +463,8 @@ describe Chef::Environment do
 
       it "should raise an error if the file does not exist" do
         expect(File).to receive(:directory?).with(Chef::Config[:environment_path]).and_return(true)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
-        expect(File).to receive(:exists?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.json")).and_return(false)
+        expect(File).to receive(:exist?).with(File.join(Chef::Config[:environment_path], "foo.rb")).and_return(false)
 
         expect do
           Chef::Environment.load("foo")

data/spec/unit/file_access_control_spec.rb

@@ -26,7 +26,7 @@ describe Chef::FileAccessControl do
         # we have to re-load the file so the proper
         # platform specific module is mixed in
         @node = Chef::Node.new
-        load File.join(File.dirname(__FILE__), "..", "..", "lib", "chef", "file_access_control.rb")
+        load File.join(__dir__, "..", "..", "lib", "chef", "file_access_control.rb")
         @resource = Chef::Resource::File.new("/tmp/a_file.txt")
         @resource.owner("toor")
         @resource.group("wheel")

data/spec/unit/knife/bootstrap_spec.rb

@@ -185,7 +185,7 @@ describe Chef::Knife::Bootstrap do
     context "when :bootstrap_template config is set to a template name" do
       let(:bootstrap_template) { "example" }
 
-      let(:builtin_template_path) { File.expand_path(File.join(File.dirname(__FILE__), "../../../lib/chef/knife/bootstrap/templates", "example.erb")) }
+      let(:builtin_template_path) { File.expand_path(File.join(__dir__, "../../../lib/chef/knife/bootstrap/templates", "example.erb")) }
 
       let(:chef_config_dir_template_path) { "/knife/chef/config/bootstrap/example.erb" }
 
@@ -206,7 +206,7 @@ describe Chef::Knife::Bootstrap do
       end
 
       before(:each) do
-        expect(File).to receive(:exists?).with(bootstrap_template).and_return(false)
+        expect(File).to receive(:exist?).with(bootstrap_template).and_return(false)
       end
 
       context "when file is available everywhere" do
@@ -215,7 +215,7 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(true)
         end
 
         it "should load the template from built-in templates" do
@@ -229,8 +229,8 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(true)
 
           it "should load the template from chef_config_dir" do
             knife.find_template.should eq(chef_config_dir_template_path)
@@ -244,9 +244,9 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(env_home_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(env_home_template_path).and_return(true)
         end
 
         it "should load the template from chef_config_dir" do
@@ -260,10 +260,10 @@ describe Chef::Knife::Bootstrap do
           configure_env_home
           configure_gem_files
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(env_home_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(env_home_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(gem_files_template_path).and_return(true)
         end
 
         it "should load the template from Gem files" do
@@ -277,9 +277,9 @@ describe Chef::Knife::Bootstrap do
           configure_gem_files
           allow(Chef::Util::PathHelper).to receive(:home).with(".chef", "bootstrap", "example.erb").and_return(nil)
 
-          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
-          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
+          expect(File).to receive(:exist?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exist?).with(gem_files_template_path).and_return(true)
         end
 
         it "should load the template from Gem files" do
@@ -472,7 +472,7 @@ describe Chef::Knife::Bootstrap do
   end
 
   describe "when transferring trusted certificates" do
-    let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(File.dirname(__FILE__), "../../data/trusted_certs")) }
+    let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(__dir__, "../../data/trusted_certs")) }
 
     let(:rendered_template) do
       knife.merge_configs
@@ -504,7 +504,7 @@ describe Chef::Knife::Bootstrap do
     end
 
     context "when :trusted_cets_dir is empty" do
-      let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(File.dirname(__FILE__), "../../data/trusted_certs_empty")) }
+      let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(__dir__, "../../data/trusted_certs_empty")) }
       it "doesn't create /etc/chef/trusted_certs if :trusted_certs_dir is empty" do
         expect(rendered_template).not_to match(%r{mkdir -p /etc/chef/trusted_certs})
       end
@@ -514,7 +514,7 @@ describe Chef::Knife::Bootstrap do
 
   context "when doing fips things" do
     let(:template_file) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "no_proxy.erb")) }
-    let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(File.dirname(__FILE__), "../../data/trusted_certs")) }
+    let(:trusted_certs_dir) { Chef::Util::PathHelper.cleanpath(File.join(__dir__, "../../data/trusted_certs")) }
 
     before do
       Chef::Config[:knife][:bootstrap_template] = template_file
@@ -570,7 +570,7 @@ describe Chef::Knife::Bootstrap do
     context "when client_d_dir is set" do
       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
 
@@ -597,7 +597,7 @@ describe Chef::Knife::Bootstrap do
       context "a nested directory structure" 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
         it "creates a file foo/bar.rb" do

data/spec/unit/knife/cookbook_download_spec.rb

@@ -94,7 +94,7 @@ describe Chef::Knife::CookbookDownload do
         let(:manifest_data) { { all_files: [] } }
         it "should determine which version to download" do
           expect(@knife).to receive(:determine_version).and_return("1.0.0")
-          expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+          expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
           @knife.run
         end
       end
@@ -111,7 +111,7 @@ describe Chef::Knife::CookbookDownload do
         end
 
         it "should print an error and exit if the cookbook download directory already exists" do
-          expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
+          expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
           expect(@knife.ui).to receive(:fatal).with(%r{/var/tmp/chef/foobar-1\.0\.0 exists}i)
           expect { @knife.run }.to raise_error(SystemExit)
         end
@@ -135,7 +135,7 @@ describe Chef::Knife::CookbookDownload do
           end
 
           it "should download the cookbook when the cookbook download directory doesn't exist" do
-            expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+            expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
             @knife.run
             %w{attributes recipes templates}.each do |segment|
               expect(@stderr.string).to match /downloading #{segment}/im
@@ -147,7 +147,7 @@ describe Chef::Knife::CookbookDownload do
           describe "with -f or --force" do
             it "should remove the existing the cookbook download directory if it exists" do
               @knife.config[:force] = true
-              expect(File).to receive(:exists?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
+              expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
               expect(FileUtils).to receive(:rm_rf).with("/var/tmp/chef/foobar-1.0.0")
               @knife.run
             end

data/spec/unit/knife/cookbook_metadata_from_file_spec.rb

@@ -34,7 +34,7 @@ describe Chef::Knife::CookbookMetadataFromFile do
   end
 
   after do
-    if File.exists?(@tgt)
+    if File.exist?(@tgt)
       File.unlink(@tgt)
     end
   end

data/spec/unit/knife/core/hashed_command_loader_spec.rb

@@ -50,7 +50,7 @@ describe Chef::Knife::SubcommandLoader::HashedCommandLoader do
 
   describe "#list_commands" do
     before do
-      allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:exist?).and_return(true)
     end
 
     it "lists all commands by category when no argument is given" do
@@ -63,7 +63,7 @@ describe Chef::Knife::SubcommandLoader::HashedCommandLoader do
 
     context "when the plugin path is invalid" do
       before do
-        expect(File).to receive(:exists?).with("/file/for/plugin/b").and_return(false)
+        expect(File).to receive(:exist?).with("/file/for/plugin/b").and_return(false)
       end
 
       it "lists all commands by category when no argument is given" do
@@ -90,7 +90,7 @@ describe Chef::Knife::SubcommandLoader::HashedCommandLoader do
     end
 
     it "loads the correct file and returns true if the command exists" do
-      allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:exist?).and_return(true)
       expect(Kernel).to receive(:load).with("/file/for/plugin/a").and_return(true)
       expect(loader.load_command(["cool_a"])).to eq(true)
     end

data/spec/unit/knife/core/ui_spec.rb

@@ -510,6 +510,7 @@ describe Chef::Knife::UI do
   describe "color" do
     context "when ui.color? => true" do
       it "returns colored output" do
+        skip "doesn't work on systems that don't correctly have terminals setup for color"
         expect(@ui).to receive(:color?).and_return(true)
         expect(@ui.color("a_bus_is", :yellow)).to eql("\e[33ma_bus_is\e[0m")
       end

data/spec/unit/knife/core/windows_bootstrap_context_spec.rb

@@ -148,24 +148,28 @@ describe Chef::Knife::Core::WindowsBootstrapContext do
 
   describe "#config_content" do
     before do
-      bootstrap_context.instance_variable_set(:@chef_config, Mash.new(config_log_level: :info,
-        config_log_location: STDOUT,
-        chef_server_url: "http://chef.example.com:4444",
-        validation_client_name: "chef-validator-testing",
-        file_cache_path: "c:/chef/cache",
-        file_backup_path: "c:/chef/backup",
-        cache_options: ({ path: "c:/chef/cache/checksums", skip_expires: true })))
+      bootstrap_context.instance_variable_set(
+        :@chef_config, Mash.new(
+          config_log_level: :info,
+          config_log_location: STDOUT,
+          chef_server_url: "http://chef.example.com:4444",
+          validation_client_name: "chef-validator-testing",
+          file_cache_path: "c:/chef/cache",
+          file_backup_path: "c:/chef/backup",
+          cache_options: ({ path: "c:/chef/cache/checksums", skip_expires: true })
+        )
+      )
     end
 
     it "generates the config file data" do
       expected = <<~EXPECTED
         echo.chef_server_url  "http://chef.example.com:4444"
         echo.validation_client_name "chef-validator-testing"
-        echo.file_cache_path   "C:/chef/cache"
-        echo.file_backup_path  "C:/chef/backup"
-        echo.cache_options     ^({:path =^> "C:/chef/cache/checksums", :skip_expires =^> true}^)
+        echo.file_cache_path   "C:\\\\chef\\\\cache"
+        echo.file_backup_path  "C:\\\\chef\\\\backup"
+        echo.cache_options     ^({:path =^> "C:\\\\chef\\\\cache\\\\checksums", :skip_expires =^> true}^)
         echo.# Using default node name ^(fqdn^)
-        echo.log_level :info
+        echo.log_level        :auto
         echo.log_location       STDOUT
       EXPECTED
       expect(bootstrap_context.config_content).to eq expected
@@ -183,7 +187,12 @@ describe Chef::Knife::Core::WindowsBootstrapContext do
 
   describe "#start_chef" do
     it "returns the expected string" do
-      expect(bootstrap_context.start_chef).to match(%r{SET \"PATH=%SystemRoot%\\system32;%SystemRoot%;%SystemRoot%\\System32\\Wbem;%SYSTEMROOT%\\System32\\WindowsPowerShell\\v1.0\\;C:\\ruby\\bin;C:\/opscode\/chef\\bin;C:\/opscode\/chef\\embedded\\bin\;%PATH%\"\n})
+      expect(bootstrap_context.start_chef).to eq(
+        <<~EOH
+          SET "PATH=%SYSTEM32%;%SystemRoot%;%SYSTEM32%\\Wbem;%SYSTEM32%\\WindowsPowerShell\\v1.0\\;C:\\ruby\\bin;C:\\opscode\\chef\\bin;C:\\opscode\\chef\\embedded\\bin;%PATH%"
+          chef-client -c C:\\chef\\client.rb -j C:\\chef\\first-boot.json
+        EOH
+      )
     end
   end