knife 18.8.68 → 19.0.102

data/spec/functional/cookbook_delete_spec.rb

@@ -75,7 +75,7 @@ describe Chef::Knife::CookbookDelete do
 
       knife.run
 
-      expect(stdout.string).to match(/#{Regexp.escape('Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)')}/)
+      expect(stdout.string).to match(/#{Regexp.escape("Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)")}/)
       expect(cb100_deleted).to be_truthy
     end
 
@@ -91,8 +91,8 @@ describe Chef::Knife::CookbookDelete do
 
       knife.run
 
-      expect(stdout.string).to match(/#{Regexp.escape('Are you sure you want to purge files')}/)
-      expect(stdout.string).to match(/#{Regexp.escape('Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)')}/)
+      expect(stdout.string).to match(/#{Regexp.escape("Are you sure you want to purge files")}/)
+      expect(stdout.string).to match(/#{Regexp.escape("Do you really want to delete obsolete-cookbook version 1.0.0? (Y/N)")}/)
       expect(cb100_deleted).to be_truthy
 
     end
@@ -123,7 +123,7 @@ describe Chef::Knife::CookbookDelete do
     end
 
     it "asks which version to delete and deletes that when not given the -a flag" do
-      cb100_deleted = cb110_deleted = cb120_deleted = nil
+      cb100_deleted = nil
       api.delete("/cookbooks/obsolete-cookbook/1.0.0", 200) { cb100_deleted = true; "[\"true\"]" }
       stdin, stdout = StringIO.new, StringIO.new
       allow(knife.ui).to receive(:stdin).and_return(stdin)

data/spec/functional/version_spec.rb

@@ -18,9 +18,8 @@ require "chef/mixin/shell_out"
 
 describe "Knife Version", :executables do
   include Chef::Mixin::ShellOut
-  let(:knife_dir) { File.join(__dir__, "..", "..", "..", "knife") }
-  xit "should be sane" do
+  let(:knife_dir) { File.join(__dir__, "..", "..") }
+  it "should be same" do
     expect(shell_out!("bundle exec knife -v", cwd: knife_dir).stdout.chomp).to match(/.*: #{Chef::Knife::VERSION}/)
   end
 end
-

data/spec/integration/config_use_spec.rb

@@ -159,10 +159,10 @@ describe "knife config use", :workstation do
       before do
         ENV["CHEF_HOME"] = path_to("chefhome"); file("chefhome/tmp", "")
         file("chefhome/.chef/credentials", <<~EOH
-        [staging]
-        client_name = "testuser"
-        client_key = "testkey.pem"
-        chef_server_url = "https://example.com/organizations/testorg"
+          [staging]
+          client_name = "testuser"
+          client_key = "testkey.pem"
+          chef_server_url = "https://example.com/organizations/testorg"
         EOH
         )
       end
@@ -180,10 +180,10 @@ describe "knife config use", :workstation do
       before do
         ENV["KNIFE_HOME"] = path_to("knifehome"); file("knifehome/tmp", "")
         file("knifehome/.chef/credentials", <<~EOH
-        [development]
-        client_name = "testuser"
-        client_key = "testkey.pem"
-        chef_server_url = "https://example.com/organizations/testorg"
+          [development]
+          client_name = "testuser"
+          client_key = "testkey.pem"
+          chef_server_url = "https://example.com/organizations/testorg"
         EOH
         )
       end

data/spec/integration/cookbook_api_ipv6_spec.rb

@@ -19,7 +19,7 @@ require "knife_spec_helper"
 require "support/shared/integration/integration_helper"
 require "chef/mixin/shell_out"
 
-describe "Knife cookbook API integration with IPv6", :workstation, :not_supported_on_gce do
+describe "Knife cookbook API integration with IPv6", :workstation do
   include IntegrationSupport
   include Chef::Mixin::ShellOut
 
@@ -62,7 +62,7 @@ describe "Knife cookbook API integration with IPv6", :workstation, :not_supporte
       Dir.mktmpdir
     end
 
-    let(:chef_dir) { File.join(__dir__, "..", "..", "..", "knife", "bin") }
+    let(:chef_dir) { File.join(__dir__, "..", "..", "bin") }
     let(:knife) { "ruby '#{chef_dir}/knife'" }
 
     let(:knife_config_flag) { "-c '#{path_to("config/knife.rb")}'" }

data/spec/integration/node_environment_set_spec.rb

@@ -40,7 +40,7 @@ describe "knife node environment set", :workstation do
 
     it "with no environment" do
       knife("node environment set adam").should_fail stderr: "FATAL: You must specify a node name and an environment.\n",
-                                                     stdout: /^USAGE: knife node environment set NODE ENVIRONMENT\n/
+        stdout: /^USAGE: knife node environment set NODE ENVIRONMENT\n/
     end
   end
 end

data/spec/integration/node_run_list_set_spec.rb

@@ -35,7 +35,7 @@ describe "knife node run list set", :workstation do
 
     it "with no role or recipe" do
       knife("node run list set cons").should_fail stderr: "FATAL: You must supply both a node name and a run list.\n",
-                                                  stdout: /^USAGE: knife node run_list set NODE ENTRIES \(options\)/m
+        stdout: /^USAGE: knife node run_list set NODE ENTRIES \(options\)/m
     end
   end
 end

data/spec/knife_spec_helper.rb

@@ -98,11 +98,6 @@ TEST_PLATFORM = TEST_NODE["platform"]
 TEST_PLATFORM_VERSION = TEST_NODE["platform_version"]
 TEST_PLATFORM_FAMILY = TEST_NODE["platform_family"]
 
-provider_priority_map ||= nil
-resource_priority_map ||= nil
-provider_handler_map ||= nil
-resource_handler_map ||= nil
-
 class UnexpectedSystemExit < RuntimeError
   def self.from(system_exit)
     new(system_exit.message).tap { |e| e.set_backtrace(system_exit.backtrace) }

data/spec/support/platforms/prof/gc.rb

@@ -24,7 +24,7 @@ module RSpec
         # GC 1 invokes.
         # Index    Invoke Time(sec)       Use Size(byte)     Total Size(byte)         Total Object                    GC time(ms)
         #     1               0.012               159240               212940                10647         0.00000000000001530000
-        LINE_PATTERN = /^\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)$/.freeze
+        LINE_PATTERN = /^\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)\s+([\d\.]*)$/
 
         def start
           ::GC::Profiler.enable unless ::GC::Profiler.enabled?

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

@@ -59,7 +59,7 @@ module IntegrationSupport
               # TODO: "force" actually means "silence all exceptions". this
               # silences a weird permissions error on Windows that we should track
               # down, but for now there's no reason for it to blow up our CI.
-              FileUtils.remove_entry_secure(@repository_dir, force = ChefUtils.windows?)
+              FileUtils.remove_entry_secure(@repository_dir, ChefUtils.windows?)
             ensure
               @repository_dir = nil
             end

data/spec/tiny_server.rb

@@ -132,7 +132,7 @@ module TinyServer
     end
 
     def call(env)
-      if response = response_for_request(env)
+      if (response = response_for_request(env))
         response.call
       else
         debug_info = { message: "no data matches the request for #{env["REQUEST_URI"]}",
@@ -144,7 +144,7 @@ module TinyServer
     end
 
     def response_for_request(env)
-      if route = @routes[env["REQUEST_METHOD"]].find { |route| route.matches_request?(env["REQUEST_URI"]) }
+      if (route = @routes[env["REQUEST_METHOD"]].find { |route| route.matches_request?(env["REQUEST_URI"]) })
         route.response
       end
     end

data/spec/unit/knife/bootstrap/templates/windows_presigned_url_spec.rb

@@ -0,0 +1,183 @@
+#
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "knife_spec_helper"
+require "chef/knife/bootstrap"
+require "chef/knife/core/windows_bootstrap_context"
+
+describe "windows-chef-client-msi.erb template with presigned URLs" do
+  let(:connection) { double("Train::Connection") }
+  let(:knife) do
+    k = Chef::Knife::Bootstrap.new(["-o", "winrm", "127.0.0.1"])
+    allow(k).to receive(:connection).and_return(connection)
+    allow(connection).to receive(:windows?).and_return(true)
+    allow(connection).to receive(:hostname).and_return("test.example.com")
+    allow(connection).to receive(:os).and_return(OpenStruct.new(family: "windows"))
+    k
+  end
+
+  describe "with presigned S3 URL containing special characters" do
+    let(:presigned_url) do
+      "https://workstation-rc3-assets.s3.us-east-1.amazonaws.com/install.ps1" \
+      "?response-content-disposition=inline" \
+      "&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD" \
+      "&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEHQaCXVzLWVhc3QtMSJIMEYCIQCfUHkC2e0%2FzlRkBc%2F2dgmp" \
+      "&X-Amz-Algorithm=AWS4-HMAC-SHA256" \
+      "&X-Amz-Credential=ASIA5LOKXA7I3346RT45%2F20251112%2Fus-east-1%2Fs3%2Faws4_request" \
+      "&X-Amz-Date=20251112T194920Z" \
+      "&X-Amz-Expires=43200" \
+      "&X-Amz-SignedHeaders=host" \
+      "&X-Amz-Signature=34d6c57d80c9a59d9f524069aa12739cf50d45b907d2a1d27e41fbf76828ad3c"
+    end
+
+    before do
+      knife.config[:bootstrap_url] = presigned_url
+    end
+
+    let(:rendered_template) { knife.render_template }
+
+    it "properly escapes percent signs in the URL for batch variable assignment" do
+      # Verify that percent signs are doubled for batch file handling
+      expect(rendered_template).to include('set "BOOTSTRAP_DOWNLOAD_URL=')
+      # Check that percent signs are properly escaped in the environment variable
+      expect(rendered_template).to match(/set "BOOTSTRAP_DOWNLOAD_URL=.*%%2F.*%%2F/)
+    end
+
+    it "uses environment variable to pass URL to PowerShell for download" do
+      # Verify that the URL is passed via environment variable to avoid batch expansion issues
+      expect(rendered_template).to include("$env:BOOTSTRAP_DOWNLOAD_URL")
+      expect(rendered_template).to include("powershell.exe -ExecutionPolicy Unrestricted")
+      # Verify download uses -Command parameter with script block for custom URLs
+      expect(rendered_template).to match(/powershell\.exe -ExecutionPolicy Unrestricted -InputFormat None -NoProfile -NonInteractive -Command "& '.*wget\.ps1'/)
+    end
+
+    it "uses -File parameter for install script execution" do
+      # Verify that the install script execution uses -File parameter for custom bootstrap URLs
+      expect(rendered_template).to match(/powershell\.exe -ExecutionPolicy Unrestricted -File "%LOCAL_DESTINATION_SCRIPT_PATH%"/)
+    end
+
+    it "does not use batch variable expansion for custom bootstrap URLs" do
+      # Verify that we're not using %REMOTE_SOURCE_SCRIPT_URL% expansion for custom URLs
+      # which would cause the percent signs to be misinterpreted
+      lines_with_bootstrap_url = rendered_template.lines.select { |line| line.include?("BOOTSTRAP_DOWNLOAD_URL") }
+      expect(lines_with_bootstrap_url).not_to be_empty
+
+      # The custom URL should not go through %VAR% expansion
+      expect(rendered_template).not_to include("%BOOTSTRAP_DOWNLOAD_URL%")
+    end
+
+    it "properly handles the URL in the cscript fallback" do
+      # Verify that the cscript fallback also uses the environment variable
+      expect(rendered_template).to include("cscript /nologo")
+      expect(rendered_template).to match(/wget\.vbs.*BOOTSTRAP_DOWNLOAD_URL/)
+    end
+
+    it "preserves all query parameters in the URL" do
+      # Verify that important query parameters are preserved
+      expect(rendered_template).to include("X-Amz-Algorithm=AWS4-HMAC-SHA256")
+      expect(rendered_template).to include("X-Amz-Credential=")
+      expect(rendered_template).to include("X-Amz-Date=")
+      expect(rendered_template).to include("X-Amz-Signature=")
+    end
+
+    it "does not corrupt encoded slashes in the credential parameter" do
+      # The most critical part - encoded slashes (%2F) must remain as %%2F in batch
+      # so they survive batch processing and become %2F when passed to PowerShell
+      expect(rendered_template).to match(/ASIA5LOKXA7I3346RT45%%2F20251112%%2Fus-east-1%%2Fs3%%2Faws4_request/)
+    end
+
+    it "does not corrupt encoded plus signs" do
+      # Verify that %2B (encoded +) becomes %%2B
+      if presigned_url.include?("%2B")
+        expect(rendered_template).to include("%%2B")
+      end
+    end
+  end
+
+  describe "with standard bootstrap URL (no special characters)" do
+    before do
+      knife.config[:license_url] = "https://chefdownload-trial.chef.io/install.sh?license_id=test-license"
+    end
+
+    let(:rendered_template) { knife.render_template }
+
+    it "uses REMOTE_SOURCE_SCRIPT_URL for standard URLs" do
+      expect(rendered_template).to include('set "REMOTE_SOURCE_SCRIPT_URL=')
+      expect(rendered_template).to include("%REMOTE_SOURCE_SCRIPT_URL%")
+    end
+
+    it "uses license URL when no bootstrap_url is provided" do
+      expect(rendered_template).to include("https://chefdownload-trial.chef.io/install.ps1?license_id=test-license")
+    end
+  end
+
+  describe "edge cases" do
+    context "when bootstrap URL contains single quotes" do
+      before do
+        knife.config[:bootstrap_url] = "https://example.com/install.ps1?param='value'"
+      end
+
+      let(:rendered_template) { knife.render_template }
+
+      it "properly escapes single quotes in PowerShell command" do
+        # Single quotes should be doubled for PowerShell string escaping
+        expect(rendered_template).to include("''")
+      end
+    end
+
+    context "when bootstrap URL contains ampersands" do
+      before do
+        knife.config[:bootstrap_url] = "https://example.com/install.ps1?a=1&b=2&c=3"
+      end
+
+      let(:rendered_template) { knife.render_template }
+
+      it "preserves ampersands in the URL" do
+        expect(rendered_template).to include("&b=2&")
+        expect(rendered_template).to include("&c=3")
+      end
+    end
+
+    context "when bootstrap URL contains equals signs" do
+      before do
+        knife.config[:bootstrap_url] = "https://example.com/install.ps1?key=value"
+      end
+
+      let(:rendered_template) { knife.render_template }
+
+      it "preserves equals signs in the URL" do
+        expect(rendered_template).to include("key=value")
+      end
+    end
+  end
+
+  describe "error messages" do
+    before do
+      knife.config[:bootstrap_url] = "https://example.com/install.ps1?X-Amz-Signature=abc123"
+    end
+
+    let(:rendered_template) { knife.render_template }
+
+    it "displays appropriate error message for custom URLs" do
+      expect(rendered_template).to include("Failed to download install script")
+      # Should not reference %REMOTE_SOURCE_SCRIPT_URL% for custom URLs
+      error_section = rendered_template.split("if NOT %DOWNLOAD_ERROR_STATUS%==0").last
+      custom_url_section = error_section.split("else").first
+      expect(custom_url_section).not_to include("%REMOTE_SOURCE_SCRIPT_URL%")
+    end
+  end
+end

data/spec/unit/knife/bootstrap_chef19_spec.rb

@@ -0,0 +1,122 @@
+#
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "knife_spec_helper"
+require "chef/knife/bootstrap"
+
+describe Chef::Knife::Bootstrap do
+  let(:knife) { described_class.new }
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:stdin) { StringIO.new }
+
+  before do
+    knife.ui = Chef::Knife::UI.new(stdout, stderr, stdin, {})
+    knife.name_args = ["test-node"]
+  end
+
+  describe "Chef Infra 19 licensing support" do
+    describe "#fetch_license" do
+      let(:bootstrap_context) { double("bootstrap_context") }
+      let(:license_handler) { double("license_handler") }
+
+      before do
+        allow(Chef::Knife::Core::BootstrapContext).to receive(:new).and_return(bootstrap_context)
+        allow(Chef::Utils::LicensingHandler).to receive(:validate!).and_return(license_handler)
+        allow(license_handler).to receive(:install_sh_url).and_return("https://example.com/install.sh")
+        allow(license_handler).to receive(:license_key).and_return("test-key")
+        allow(license_handler).to receive(:omnitruck_url).and_return("https://example.com/%s")
+        allow(license_handler).to receive(:license_type).and_return("trial")
+      end
+
+      context "when license is required for Chef Infra 19" do
+        before do
+          allow(bootstrap_context).to receive(:chef_ice?).and_return(true)
+        end
+
+        it "fetches and sets license configuration" do
+          expect(ChefLicensing::Config).to receive(:require_license_for).and_yield
+
+          knife.config[:bootstrap_version] = "19.0.0"
+          knife.send(:fetch_license)
+
+          expect(knife.config[:license_url]).to eq("https://example.com/install.sh")
+          expect(knife.config[:license_id]).to eq("test-key")
+          expect(knife.config[:omnitruck_url]).to eq("https://example.com/%s")
+          expect(knife.config[:license_type]).to eq("trial")
+        end
+      end
+
+      context "when custom bootstrap URL is provided" do
+        it "skips license fetching" do
+          expect(ChefLicensing::Config).not_to receive(:require_license_for)
+
+          knife.config[:bootstrap_url] = "https://custom.example.com/install.sh"
+          knife.send(:fetch_license)
+
+          expect(knife.config[:license_url]).to be_nil
+        end
+      end
+
+      context "when custom bootstrap template is provided" do
+        it "skips license fetching" do
+          expect(ChefLicensing::Config).not_to receive(:require_license_for)
+
+          knife.config[:bootstrap_template] = "custom-template"
+          knife.send(:fetch_license)
+
+          expect(knife.config[:license_url]).to be_nil
+        end
+      end
+    end
+
+    describe "command line options" do
+      it "accepts --bootstrap-product option" do
+        knife.config[:bootstrap_product] = "chef-ice"
+        expect(knife.config[:bootstrap_product]).to eq("chef-ice")
+      end
+
+      it "accepts --license-key option" do
+        knife.config[:chef_license_key] = "test-license-key"
+        expect(knife.config[:chef_license_key]).to eq("test-license-key")
+      end
+
+      it "accepts --license-url option" do
+        knife.config[:chef_license_server] = "https://example.com/license"
+        expect(knife.config[:chef_license_server]).to eq("https://example.com/license")
+      end
+    end
+
+    describe "option descriptions" do
+      let(:bootstrap_product_option) { knife.class.options[:bootstrap_product] }
+      let(:license_key_option) { knife.class.options[:chef_license_key] }
+      let(:license_url_option) { knife.class.options[:chef_license_server] }
+
+      it "has proper description for bootstrap_product" do
+        expect(bootstrap_product_option[:description]).to include("Product")
+      end
+
+      it "has proper description for license_key" do
+        expect(license_key_option[:description]).to include("Chef License key")
+      end
+
+      it "has proper description for license_url" do
+        expect(license_url_option[:description]).to include("Chef License server")
+      end
+    end
+  end
+end

data/spec/unit/knife/bootstrap_spec.rb

@@ -59,7 +59,7 @@ describe Chef::Knife::Bootstrap do
 
     describe "when a license is not required" do
       it "does not set the chef_license" do
-        expect(acceptor).to receive(:license_required?).and_return(false)
+        expect(acceptor).to receive(:license_required?).with("chef", anything).and_return(false)
         knife.check_eula_license
         expect(Chef::Config[:chef_license]).to eq(nil)
       end
@@ -67,9 +67,9 @@ describe Chef::Knife::Bootstrap do
 
     describe "when a license is required" do
       it "sets the chef_license" do
-        expect(acceptor).to receive(:license_required?).and_return(true)
-        expect(acceptor).to receive(:id_from_mixlib).and_return("id")
-        expect(acceptor).to receive(:check_and_persist)
+        expect(acceptor).to receive(:license_required?).with("chef", anything).and_return(true)
+        expect(acceptor).to receive(:id_from_mixlib).with("chef").and_return("id")
+        expect(acceptor).to receive(:check_and_persist).with("id", anything)
         expect(acceptor).to receive(:acceptance_value).and_return("accept-no-persist")
         knife.check_eula_license
         expect(Chef::Config[:chef_license]).to eq("accept-no-persist")
@@ -100,6 +100,118 @@ describe Chef::Knife::Bootstrap do
     end
   end
 
+  context "#fetch_license" do
+    let(:licensing_config_mock) { double("ChefLicensing::Config") }
+    let(:licensing_handler_mock) { double("Chef::Utils::LicensingHandler") }
+    let(:license_mock) { double("License") }
+
+    before do
+      stub_const("ChefLicensing::Config", licensing_config_mock)
+      stub_const("Chef::Utils::LicensingHandler", licensing_handler_mock)
+    end
+
+    context "when bootstrap_url is provided" do
+      it "returns early without calling licensing" do
+        knife.config[:bootstrap_url] = "https://example.com/bootstrap.sh"
+        expect(licensing_config_mock).not_to receive(:require_license_for)
+
+        knife.send(:fetch_license)
+      end
+    end
+
+    context "when bootstrap_template is provided" do
+      it "returns early without calling licensing" do
+        knife.config[:bootstrap_template] = "custom-template"
+
+        expect(licensing_config_mock).not_to receive(:require_license_for)
+
+        knife.send(:fetch_license)
+      end
+    end
+
+    context "when both bootstrap_url and bootstrap_template are provided" do
+      it "returns early without calling licensing" do
+        knife.config[:bootstrap_url] = "https://example.com/bootstrap.sh"
+        knife.config[:bootstrap_template] = "custom-template"
+
+        expect(licensing_config_mock).not_to receive(:require_license_for)
+
+        knife.send(:fetch_license)
+      end
+    end
+
+    context "when neither bootstrap_url nor bootstrap_template are provided" do
+      before do
+        knife.config[:bootstrap_url] = nil
+        knife.config[:bootstrap_template] = nil
+      end
+
+      it "validates license and sets license configuration" do
+        expect(license_mock).to receive(:install_sh_url).and_return("https://example.com/install.sh")
+        expect(license_mock).to receive(:license_key).and_return("test-license-key")
+        expect(license_mock).to receive(:omnitruck_url).and_return("https://example.com/omnitruck")
+        expect(license_mock).to receive(:license_type).and_return("commercial")
+
+        expect(licensing_handler_mock).to receive(:validate!).with(no_args).and_return(license_mock)
+
+        expect(licensing_config_mock).to receive(:require_license_for).and_yield
+
+        knife.send(:fetch_license)
+
+        expect(knife.config[:license_url]).to eq("https://example.com/install.sh")
+        expect(knife.config[:license_id]).to eq("test-license-key")
+        expect(knife.config[:omnitruck_url]).to eq("https://example.com/omnitruck")
+        expect(knife.config[:license_type]).to eq("commercial")
+      end
+
+      it "handles licensing validation errors gracefully" do
+        expect(licensing_handler_mock).to receive(:validate!).with(no_args).and_raise(StandardError.new("License validation failed"))
+
+        expect(licensing_config_mock).to receive(:require_license_for).and_yield
+
+        expect { knife.send(:fetch_license) }.to raise_error(StandardError, "License validation failed")
+      end
+
+      it "properly sets all license configuration values from the license object" do
+        expect(license_mock).to receive(:install_sh_url).and_return("https://omnitruck.chef.io/install.sh")
+        expect(license_mock).to receive(:license_key).and_return("ABCD-1234-EFGH-5678")
+        expect(license_mock).to receive(:omnitruck_url).and_return("https://omnitruck.chef.io")
+        expect(license_mock).to receive(:license_type).and_return("trial")
+
+        expect(licensing_handler_mock).to receive(:validate!).with(no_args).and_return(license_mock)
+        expect(licensing_config_mock).to receive(:require_license_for).and_yield
+
+        # Verify that config values are nil before the call
+        expect(knife.config[:license_url]).to be_nil
+        expect(knife.config[:license_id]).to be_nil
+        expect(knife.config[:omnitruck_url]).to be_nil
+        expect(knife.config[:license_type]).to be_nil
+
+        knife.send(:fetch_license)
+
+        # Verify all license values are properly set
+        expect(knife.config[:license_url]).to eq("https://omnitruck.chef.io/install.sh")
+        expect(knife.config[:license_id]).to eq("ABCD-1234-EFGH-5678")
+        expect(knife.config[:omnitruck_url]).to eq("https://omnitruck.chef.io")
+        expect(knife.config[:license_type]).to eq("trial")
+      end
+
+      context "when ChefLicensing::Config.require_license_for does not yield" do
+        it "does not call licensing handler" do
+          expect(licensing_config_mock).to receive(:require_license_for).and_return(nil)
+          expect(licensing_handler_mock).not_to receive(:validate!)
+
+          knife.send(:fetch_license)
+
+          expect(knife.config[:license_url]).to be_nil
+          expect(knife.config[:license_id]).to be_nil
+          expect(knife.config[:omnitruck_url]).to be_nil
+          expect(knife.config[:license_type]).to be_nil
+        end
+      end
+    end
+  end
+
   context "#bootstrap_template" do
     it "should default to chef-full" do
       expect(knife.bootstrap_template).to be_a_kind_of(String)
@@ -371,6 +483,7 @@ describe Chef::Knife::Bootstrap do
         knife.merge_configs
         allow(knife).to receive(:validate_name_args!)
         expect(knife).to receive(:check_eula_license)
+        expect(knife).to receive(:fetch_license)
 
         expect { knife.run }.to raise_error(Chef::Exceptions::BootstrapCommandInputError)
         jsonfile.close
@@ -586,7 +699,7 @@ describe Chef::Knife::Bootstrap do
       end
 
       it "creates /etc/chef/client.d" do
-        expect(rendered_template).to match("mkdir -p /etc/chef/client\.d")
+        expect(rendered_template).to match("mkdir -p /etc/chef/client.d")
       end
 
       context "a flat directory structure" do
@@ -797,7 +910,7 @@ describe Chef::Knife::Bootstrap do
   context "validating use_sudo_password option" do
     it "use_sudo_password contains description and long params for help" do
       expect(knife.options).to(have_key(:use_sudo_password)) \
-        && expect(knife.options[:use_sudo_password][:description].to_s).not_to(eq(""))\
+        && expect(knife.options[:use_sudo_password][:description].to_s).not_to(eq("")) \
         && expect(knife.options[:use_sudo_password][:long].to_s).not_to(eq(""))
     end
   end
@@ -1144,7 +1257,6 @@ describe Chef::Knife::Bootstrap do
           before do
             # We will use knife's actual config since these tests
             # have assumptions based on CLI default values
-            config = {}
           end
 
           let(:expected_result) do
@@ -1710,6 +1822,7 @@ describe Chef::Knife::Bootstrap do
   describe "#run" do
     it "performs the steps we expect to run a bootstrap" do
       expect(knife).to receive(:check_eula_license)
+      expect(knife).to receive(:fetch_license)
       expect(knife).to receive(:validate_name_args!).ordered
       expect(knife).to receive(:validate_protocol!).ordered
       expect(knife).to receive(:validate_first_boot_attributes!).ordered
@@ -1980,6 +2093,7 @@ describe Chef::Knife::Bootstrap do
   it "verifies that a server to bootstrap was given as a command line arg" do
     knife.name_args = nil
     expect(knife).to receive(:check_eula_license)
+    expect(knife).to receive(:fetch_license)
     expect { knife.run }.to raise_error(SystemExit)
     expect(stderr.string).to match(/ERROR:.+FQDN or ip/)
   end