knife 18.8.68 → 19.0.102

data/spec/unit/knife/configure_spec.rb

@@ -157,9 +157,9 @@ describe Chef::Knife::Configure do
     expect(::File).to receive(:open).with("/home/you/.chef/credentials", "w").and_yield config_file
     @knife.config[:repository] = "/home/you/chef-repo"
     @knife.run
-    expect(config_file.string).to match(/^client_name\s+=\s+'#{Etc.getlogin}'$/)
-    expect(config_file.string).to match(%r{^client_key\s+=\s+'/home/you/.chef/#{Etc.getlogin}.pem'$})
-    expect(config_file.string).to match(/^chef_server_url\s+=\s+'#{default_server_url}'$/)
+    expect(config_file.string).to match(/^client_name\s+=\s+'#{Regexp.escape(Etc.getlogin)}'$/)
+    expect(config_file.string).to match(/^client_key\s+=\s+'#{Regexp.escape("/home/you/.chef/#{Etc.getlogin}.pem")}'$/)
+    expect(config_file.string).to match(/^chef_server_url\s+=\s+'#{Regexp.escape(default_server_url)}'$/)
   end
 
   it "creates a new client when given the --initial option" do

data/spec/unit/knife/cookbook_list_spec.rb

@@ -59,7 +59,7 @@ describe Chef::Knife::CookbookList do
         allow(@rest_mock).to receive(:get).and_return(@cookbook_data)
         @knife.run
         @cookbook_names.each do |item|
-          pattern = /#{Regexp.escape(@cookbook_data[item]['versions'].first['url'])}/
+          pattern = /#{Regexp.escape(@cookbook_data[item]["versions"].first["url"])}/
           expect(@stdout.string).to match pattern
         end
       end

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

@@ -284,4 +284,141 @@ describe Chef::Knife::Core::BootstrapContext do
       end
     end
   end
+
+  describe "when using disable_license_activation" do
+    let(:config) { { license_id: "123", color: false } }
+    # it "by default it should return license" do
+    #   expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json --no-color"
+    # end
+
+    it "doesn't return the chef-license-key in the start_chef command if it set" do
+      config[:disable_license_activation] = true
+      expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json --no-color"
+    end
+  end
+
+  describe "#chef_ice?" do
+    context "when product_to_install is chef-ice" do
+      let(:config) { { bootstrap_version: "19.0.0" } }
+
+      it "returns true for Chef Infra 19" do
+        expect(bootstrap_context.chef_ice?).to be true
+      end
+    end
+
+    context "when product_to_install is chef" do
+      let(:config) { { bootstrap_version: "18.0.0" } }
+
+      it "returns false for Chef Infra 18" do
+        expect(bootstrap_context.chef_ice?).to be false
+      end
+    end
+
+    context "when bootstrap_product is explicitly set to chef-ice" do
+      let(:config) { { bootstrap_product: "chef-ice" } }
+
+      it "returns true" do
+        expect(bootstrap_context.chef_ice?).to be true
+      end
+    end
+
+    context "when bootstrap_product is explicitly set to chef" do
+      let(:config) { { bootstrap_product: "chef" } }
+
+      it "returns false" do
+        expect(bootstrap_context.chef_ice?).to be false
+      end
+    end
+  end
+
+  describe "#product_to_install" do
+    context "when bootstrap_product is explicitly set" do
+      let(:config) { { bootstrap_product: "chef-ice" } }
+
+      it "returns the explicitly set product" do
+        expect(bootstrap_context.product_to_install).to eq "chef-ice"
+      end
+    end
+
+    context "when bootstrap_version is latest" do
+      let(:config) { { channel: "unstable" } }
+
+      it "returns chef-ice for latest version" do
+        expect(bootstrap_context.product_to_install).to eq "chef-ice"
+      end
+    end
+
+    context "when bootstrap_version starts with 19" do
+      let(:config) { { bootstrap_version: "19.0.0" } }
+
+      it "returns chef-ice for version 19.x.x" do
+        expect(bootstrap_context.product_to_install).to eq "chef-ice"
+      end
+    end
+
+    context "when bootstrap_version is older than 19" do
+      let(:config) { { bootstrap_version: "18.4.0" } }
+
+      it "returns chef for older versions" do
+        expect(bootstrap_context.product_to_install).to eq "chef"
+      end
+    end
+
+    context "when no version is specified and channel is stable" do
+      let(:config) { { channel: "stable" } }
+
+      it "returns chef-ice if current Chef version is 19+" do
+        # Assuming Chef::VERSION starts with "19"
+        if Chef::VERSION.split(".").first.to_i >= 19
+          expect(bootstrap_context.product_to_install).to eq "chef-ice"
+        else
+          expect(bootstrap_context.product_to_install).to eq "chef"
+        end
+      end
+    end
+  end
+
+  describe "#start_chef with licensing" do
+    context "when license is required and license_key is provided" do
+      let(:config) { { bootstrap_version: "19.0.0", license_key: "test-license-key" } }
+
+      it "includes license environment variable in start_chef command" do
+        expected = 'CHEF_LICENSE_KEY="test-license-key" chef-client -j /etc/chef/first-boot.json'
+        expect(bootstrap_context.start_chef).to eq expected
+      end
+    end
+
+    context "when license is required and license_id is provided" do
+      let(:config) { { bootstrap_version: "19.0.0", license_id: "test-license-id" } }
+
+      it "includes license environment variable with license_id in start_chef command" do
+        expected = 'CHEF_LICENSE_KEY="test-license-id" chef-client -j /etc/chef/first-boot.json'
+        expect(bootstrap_context.start_chef).to eq expected
+      end
+    end
+
+    context "when license is required but no license key/id provided" do
+      let(:config) { { bootstrap_version: "19.0.0" } }
+
+      it "does not include license environment variable" do
+        expected = "chef-client -j /etc/chef/first-boot.json"
+        expect(bootstrap_context.start_chef).to eq expected
+      end
+    end
+
+    context "when license is not required" do
+      let(:config) { { bootstrap_version: "18.0.0", license_key: "test-license-key" } }
+
+      it "does not include license environment variable even if license key provided" do
+        expected = "chef-client -j /etc/chef/first-boot.json"
+        expect(bootstrap_context.start_chef).to eq expected
+      end
+    end
+  end
+
+  describe "#detect_package_manager" do
+    it "returns empty string for base implementation" do
+      expect(bootstrap_context.detect_package_manager).to eq ""
+    end
+  end
 end

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

@@ -0,0 +1,82 @@
+#
+# 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/core/windows_bootstrap_context"
+
+describe Chef::Knife::Core::WindowsBootstrapContext do
+  let(:config) { { foo: :bar, color: true } }
+  let(:run_list) { Chef::RunList.new("recipe[tmux]", "role[base]") }
+  let(:chef_config) do
+    {
+      config_log_level: "info",
+      config_log_location: "/tmp/log",
+      validation_key: File.join(CHEF_SPEC_DATA, "ssl", "private_key.pem"),
+      chef_server_url: "http://chef.example.com:4444",
+      validation_client_name: "chef-validator-testing",
+    }
+  end
+
+  let(:secret) { nil }
+
+  subject(:bootstrap_context) { described_class.new(config, run_list, chef_config, secret) }
+
+  describe "Chef Infra 19 licensing support" do
+
+    describe "install_command with licensing" do
+      let(:executor_quote) { '"' }
+
+      context "when license is required and license_key is provided" do
+        let(:config) { { bootstrap_version: "19.0.0", license_key: "test-license-key" } }
+
+        it "includes license environment variable in install command" do
+          command = bootstrap_context.send(:install_command, executor_quote)
+          expect(command).to include("set CHEF_LICENSE_KEY=test-license-key")
+          expect(command).to include("msiexec /qn")
+        end
+      end
+
+      context "when license is required and license_id is provided" do
+        let(:config) { { bootstrap_version: "19.0.0", license_id: "test-license-id" } }
+
+        it "includes license environment variable with license_id in install command" do
+          command = bootstrap_context.send(:install_command, executor_quote)
+          expect(command).to include("set CHEF_LICENSE_KEY=test-license-id")
+        end
+      end
+
+      context "when license is required but no license key/id provided" do
+        let(:config) { { bootstrap_version: "19.0.0" } }
+
+        it "does not include license environment variable" do
+          command = bootstrap_context.send(:install_command, executor_quote)
+          expect(command).not_to include("CHEF_LICENSE_KEY")
+          expect(command).to include("msiexec /qn")
+        end
+      end
+
+      context "when license is not required" do
+        let(:config) { { bootstrap_version: "18.0.0", license_key: "test-license-key" } }
+
+        it "does not include license environment variable even if license key provided" do
+          command = bootstrap_context.send(:install_command, executor_quote)
+          expect(command).not_to include("CHEF_LICENSE_KEY")
+        end
+      end
+    end
+  end
+end

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

@@ -186,39 +186,70 @@ describe Chef::Knife::Core::WindowsBootstrapContext do
   end
 
   describe "#start_chef" do
-    it "returns the expected string" do
+    # These tests are for Chef 18 behavior, so we need to specify version 18
+    let(:config) { { bootstrap_version: "18" } }
+
+    it "returns the expected string with default values" do
+      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;C:\\hab\\bin;%PATH%"
+          chef-client -c C:\\chef\\client.rb -j C:\\chef\\first-boot.json
+        EOH
+      )
+    end
+
+    it "returns the expected string with license_id" do
+      config[:license_id] = "123"
+
+      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;C:\\hab\\bin;%PATH%"
+          chef-client -c C:\\chef\\client.rb -j C:\\chef\\first-boot.json
+        EOH
+      )
+    end
+
+    it "exclude the license key argument when disable_license_activation is true" do
+      config[:disable_license_activation] = true
+      config[:license_id] = "123"
+
       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%"
+          SET "PATH=%SYSTEM32%;%SystemRoot%;%SYSTEM32%\\Wbem;%SYSTEM32%\\WindowsPowerShell\\v1.0\\;C:\\ruby\\bin;C:\\opscode\\chef\\bin;C:\\opscode\\chef\\embedded\\bin;C:\\hab\\bin;%PATH%"
           chef-client -c C:\\chef\\client.rb -j C:\\chef\\first-boot.json
         EOH
       )
     end
   end
 
+  describe "#start_chef with bootstrap_url and chef-ice" do
+    let(:config) { { bootstrap_url: "https://example.com/install.ps1" } }
+
+    before do
+      allow(bootstrap_context).to receive(:chef_ice?).and_return(true)
+    end
+
+    it "includes HAB_LICENSE and uses hab pkg exec" do
+      expect(bootstrap_context.start_chef).to eq(
+        <<~EOH
+          SET "PATH=%SYSTEM32%;%SystemRoot%;%SYSTEM32%\\Wbem;%SYSTEM32%\\WindowsPowerShell\\v1.0\\;C:\\hab\\bin;%PATH%"
+          SET "HAB_LICENSE=accept-no-persist"
+          hab pkg exec chef/chef-infra-client chef-client -c C:\\chef\\client.rb -j C:\\chef\\first-boot.json
+        EOH
+      )
+    end
+  end
+
   describe "msi_url" do
     context "when msi_url config option is not set" do
       let(:config) { { channel: "stable" } }
-      before do
-        expect(bootstrap_context).to receive(:version_to_install).and_return("something")
-      end
 
-      it "returns a chef.io msi url with minimal url parameters" do
-        reference_url = "https://omnitruck.chef.io/chef/download?p=windows&channel=stable&v=something"
-        expect(bootstrap_context.msi_url).to eq(reference_url)
+      it "returns nil when no msi_url is provided" do
+        expect(bootstrap_context.msi_url).to be_nil
       end
 
-      it "returns a chef.io msi url with provided url parameters substituted" do
-        reference_url = "https://omnitruck.chef.io/chef/download?p=windows&channel=stable&pv=machine&m=arch&DownloadContext=ctx&v=something"
-        expect(bootstrap_context.msi_url("machine", "arch", "ctx")).to eq(reference_url)
-      end
-
-      context "when a channel is provided in config" do
-        let(:config) { { channel: "current" } }
-        it "returns a chef.io msi url with the requested channel" do
-          reference_url = "https://omnitruck.chef.io/chef/download?p=windows&channel=current&v=something"
-          expect(bootstrap_context.msi_url).to eq(reference_url)
-        end
+      it "returns nil even with parameters when no msi_url is provided" do
+        expect(bootstrap_context.msi_url).to be_nil
       end
     end
 
@@ -231,51 +262,7 @@ describe Chef::Knife::Core::WindowsBootstrapContext do
       end
 
       it "doesn't introduce any unnecessary query parameters if provided by the template" do
-        expect(bootstrap_context.msi_url("machine", "arch", "ctx")).to eq(custom_url)
-      end
-    end
-
-    context "with licensing changes" do
-      let(:config) { { channel: "stable", bootstrap_version: "latest" } }
-
-      it "should return the old omnitruck api in case license not present" do
-        nil_license_obj = Chef::Utils::LicensingHandler.new(nil, nil)
-        expect(Chef::Utils::LicensingHandler).to receive(:validate!).and_return(nil_license_obj)
-        b = Chef::Knife::Bootstrap.new([])
-        b.send(:fetch_license)
-        config.merge!(b.config)
-
-        expect(bootstrap_context.msi_url).to eq("https://omnitruck.chef.io/chef/download?p=windows&channel=stable&v=latest")
-      end
-
-      it "should return the correct msi_url for trial license" do
-        license_obj_trial = Chef::Utils::LicensingHandler.new("key-trial-123", "trial")
-        expect(Chef::Utils::LicensingHandler).to receive(:validate!).and_return(license_obj_trial)
-
-        b = Chef::Knife::Bootstrap.new([])
-        b.send(:fetch_license)
-        config.merge!(b.config)
-        expect(bootstrap_context.msi_url).to eq("https://chefdownload-trial.chef.io/stable/chef/download?license_id=key-trial-123&p=windows&v=latest")
-      end
-
-      it "should return the correct msi_url for commercial license" do
-        license_obj_commercial = Chef::Utils::LicensingHandler.new("key-commercial-123", "commercial")
-        expect(Chef::Utils::LicensingHandler).to receive(:validate!).and_return(license_obj_commercial)
-
-        b = Chef::Knife::Bootstrap.new([])
-        b.send(:fetch_license)
-        config.merge!(b.config)
-        expect(bootstrap_context.msi_url).to eq("https://chefdownload-commerical.chef.io/stable/chef/download?license_id=key-commercial-123&p=windows&v=latest")
-      end
-
-      it "should return the omnitruck url in case of airgapped env" do
-        # In case of connection issues with the licensing service, the library will raise this exception
-        expect(ChefLicensing::LicenseKeyFetcher).to receive(:fetch).and_raise(ChefLicensing::RestfulClientConnectionError)
-
-        b = Chef::Knife::Bootstrap.new([])
-        b.send(:fetch_license)
-        config.merge!(b.config)
-        expect(bootstrap_context.msi_url).to eq("https://omnitruck.chef.io/chef/download?p=windows&channel=stable&v=latest")
+        expect(bootstrap_context.msi_url).to eq(custom_url)
       end
     end
   end

data/spec/unit/knife/license_spec.rb

@@ -92,4 +92,4 @@ describe Chef::Knife::License do
       end
     end
   end
-end
+end

data/spec/unit/knife/search_spec.rb

@@ -59,14 +59,14 @@ describe Chef::Knife::Search do
           knife.config[:query] = ":"
 
           expect { knife.run }.to raise_error(SystemExit)
-          expect(stderr.string).to match /Please specify query as an argument or an option via -q, not both/im
+          expect(stderr.string).to match(/Please specify query as an argument or an option via -q, not both/im)
         end
 
         it "should fail if no query passed" do
           knife.name_args = []
 
           expect { knife.run }.to raise_error(SystemExit)
-          expect(stderr.string).to match /No query specified/im
+          expect(stderr.string).to match(/No query specified/im)
         end
       end
 
@@ -145,4 +145,4 @@ describe Chef::Knife::Search do
       end
     end
   end
-end
+end

data/spec/unit/knife/supermarket_install_spec.rb

@@ -28,8 +28,8 @@ describe Chef::Knife::SupermarketInstall do
   let(:archive) { double(Mixlib::Archive, extract: true) }
   let(:repo) do
     double(sanity_check: true, reset_to_default_state: true,
-           prepare_to_import: true, finalize_updates_to: true,
-           merge_updates_from: true)
+      prepare_to_import: true, finalize_updates_to: true,
+      merge_updates_from: true)
   end
   let(:install_path) do
     if ChefUtils.windows?
@@ -137,7 +137,6 @@ describe Chef::Knife::SupermarketInstall do
       knife.name_args = ["getting-started"]
       knife.config[:use_current_branch] = true
       knife.config[:no_deps] = true
-      upstream_file = File.join(install_path, "getting-started.tar.gz")
       expect(repo).not_to receive(:prepare_to_import)
       expect(repo).not_to receive(:reset_to_default_state)
       knife.run
@@ -192,11 +191,11 @@ describe Chef::Knife::SupermarketInstall do
     end
 
     it "rasies an error if it finds no metadata file" do
-      expect { knife.preferred_metadata }.to raise_error { |error|
+      expect { knife.preferred_metadata }.to(raise_error { |error|
         expect(error).to be_a(Chef::Exceptions::MetadataNotFound)
         expect(error.cookbook_name).to eq("post-punk-kitchen")
         expect(error.install_path).to eq(install_path)
-      }
+      })
     end
 
   end

data/spec/unit/knife/utils/licensing_handler_chef19_spec.rb

@@ -0,0 +1,144 @@
+#
+# 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/utils/licensing_handler"
+
+describe Chef::Utils::LicensingHandler do
+  let(:license_key) { "test-license-key" }
+  let(:license_type) { "trial" }
+  let(:handler) { described_class.new(license_key, license_type) }
+
+  describe "#initialize" do
+    it "sets license_key and license_type" do
+      expect(handler.license_key).to eq(license_key)
+      expect(handler.license_type).to eq(license_type)
+    end
+  end
+
+  describe "#omnitruck_url" do
+    context "with trial license" do
+      let(:license_type) { "trial" }
+
+      it "returns chefdownload-trial.chef.io URL with license_id parameter" do
+        expected_url = "https://chefdownload-trial.chef.io/%s?license_id=#{license_key}"
+        expect(handler.omnitruck_url).to eq(expected_url)
+      end
+    end
+
+    context "with free license" do
+      let(:license_type) { "free" }
+
+      it "returns chefdownload-trial.chef.io URL with license_id parameter" do
+        expected_url = "https://chefdownload-trial.chef.io/%s?license_id=#{license_key}"
+        expect(handler.omnitruck_url).to eq(expected_url)
+      end
+    end
+
+    context "with commercial license" do
+      let(:license_type) { "commercial" }
+
+      it "returns commercial download URL with license_id parameter" do
+        expected_url = "https://chefdownload-commercial.chef.io/%s?license_id=#{license_key}"
+        expect(handler.omnitruck_url).to eq(expected_url)
+      end
+    end
+  end
+
+  describe "#install_sh_url" do
+    it "returns formatted URL for install.sh" do
+      expected_url = handler.omnitruck_url.gsub("%s", "install.sh")
+      expect(handler.install_sh_url).to eq(expected_url)
+    end
+  end
+
+  describe "DOWNLOAD_URLS constant" do
+    it "has correct URLs for each license type" do
+      expect(described_class::DOWNLOAD_URLS["free"]).to eq("https://chefdownload-trial.chef.io")
+      expect(described_class::DOWNLOAD_URLS["trial"]).to eq("https://chefdownload-trial.chef.io")
+      expect(described_class::DOWNLOAD_URLS["commercial"]).to eq("https://chefdownload-commercial.chef.io")
+    end
+  end
+
+  describe ".validate!" do
+    let(:license_metadata) { double("license_metadata", id: "test-id", license_type: "trial") }
+    let(:licenses_metadata) { double("licenses_metadata", last: license_metadata) }
+
+    before do
+      allow(ChefLicensing).to receive(:fetch_and_persist).and_return(["test-license"])
+      allow(ChefLicensing::Api::Describe).to receive(:list).and_return(licenses_metadata)
+    end
+
+    it "validates license and returns handler instance" do
+      result = described_class.validate!
+
+      expect(result).to be_a(described_class)
+      expect(result.license_key).to eq("test-id")
+      expect(result.license_type).to eq("trial")
+    end
+
+    it "fetches licenses from licensing service" do
+      expect(ChefLicensing).to receive(:fetch_and_persist).and_return(["test-license"])
+
+      described_class.validate!
+    end
+
+    it "describes licenses with license keys" do
+      expect(ChefLicensing::Api::Describe).to receive(:list).with(
+        hash_including(license_keys: ["test-license"])
+      )
+
+      described_class.validate!
+    end
+  end
+
+  describe ".check_software_entitlement!" do
+    let(:ui) { double("ui") }
+
+    context "when entitlement check succeeds" do
+      it "calls ChefLicensing.check_software_entitlement!" do
+        expect(ChefLicensing).to receive(:check_software_entitlement!)
+
+        described_class.check_software_entitlement!(ui)
+      end
+    end
+
+    context "when software is not entitled" do
+      before do
+        allow(ChefLicensing).to receive(:check_software_entitlement!).and_raise(ChefLicensing::SoftwareNotEntitled)
+      end
+
+      it "displays error message and exits" do
+        expect(ui).to receive(:error).with("License is not entitled to use Workstation.")
+        expect { described_class.check_software_entitlement!(ui) }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when licensing error occurs" do
+      let(:licensing_error) { ChefLicensing::Error.new("Test error") }
+
+      before do
+        allow(ChefLicensing).to receive(:check_software_entitlement!).and_raise(licensing_error)
+      end
+
+      it "displays error message and exits" do
+        expect(ui).to receive(:error).with("Test error")
+        expect { described_class.check_software_entitlement!(ui) }.to raise_error(SystemExit)
+      end
+    end
+  end
+end