knife 17.4.18 → 17.4.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70c4e18afa9b4762387d8a0a6c9c75bca9e1e42723a041147bea36c2efaae176
-  data.tar.gz: '00953cd3c86ab1e11eb9ddb9a8fdf8fffbae40705671090169411877fa72a069'
+  metadata.gz: 5bce1fdf8a026140f71d734c579f29ac19eeb68da7965ebc5426cdad7c00eb51
+  data.tar.gz: b10eafb114347dec04f3e1f0aaf0c1a9d9806ba2f76cfad8b57c1065e72bb0b9
 SHA512:
-  metadata.gz: f2d2130d599b56a3d43bbbbe5f64407dfc19aaec9df4ea87af2b835b950dda18ef1b9eb6cee28fae9ee05bafef8b6fe180219b36f1f7fbe5333b4efcd3236002
-  data.tar.gz: 0d500fcfd9e9aa0830d04bae3f9d4e3712ab52bf6fcd9b87c4f0e3bbb2149f8568d179c41656189b7614bdbdd91e8dbd5d14800c38771275466c5e3c9e0c78f0
+  metadata.gz: 4a5df15d3687dddd23e0469fb170fd2ea6325ee186378f98a334f7a1d42757195d2dc541ff9b370b624f949a0ab06de11d607b2029559788f0a1e406b0d8ac8d
+  data.tar.gz: 24414b3f673ae91d6c837c3b3c8740cf60746dc337c770b752fa1baf65f1773510ea9a8c72ee19e2979d70688ca1810a502afbe43092c321ae0cc1dceb8a8e69

data/Gemfile

@@ -17,10 +17,10 @@ group(:omnibus_package, :pry) do
 end
 
 group(:chefstyle) do
-  gem "chefstyle", git: "https://github.com/chef/chefstyle.git", branch: "master"
+  gem "chefstyle", git: "https://github.com/chef/chefstyle.git", branch: "main"
 end
 
-gem "ohai", git: "https://github.com/chef/ohai.git", branch: "master"
+gem "ohai", git: "https://github.com/chef/ohai.git", branch: "main"
 gem "chef", path: ".."
 gem "chef-utils", path: File.expand_path("../chef-utils", __dir__) if File.exist?(File.expand_path("../chef-utils", __dir__))
 gem "chef-config", path: File.expand_path("../chef-config", __dir__) if File.exist?(File.expand_path("../chef-config", __dir__))

data/knife.gemspec

@@ -30,8 +30,7 @@ Gem::Specification.new do |s|
   s.add_dependency "net-ssh-multi", "~> 1.2", ">= 1.2.1"
   s.add_dependency "ed25519", "~> 1.2" # ed25519 ssh key support
   s.add_dependency "bcrypt_pbkdf", "~> 1.1" # ed25519 ssh key support
-  # we can't use this gem until illegal instruction issues are resolved
-  # s.add_dependency "x25519" # ed25519 KEX module
+  s.add_dependency "x25519", ">= 1.0.9" # ed25519 KEX module. 1.0.9+ required to resolve sigill failures
   s.add_dependency "highline", ">= 1.6.9", "< 3" # Used in UI to present a list, no other usage.
 
   s.add_dependency "tty-prompt", "~> 0.21" # knife ui.ask prompt
@@ -52,7 +51,7 @@ Gem::Specification.new do |s|
 
   s.metadata = {
     "bug_tracker_uri"   => "https://github.com/chef/chef/issues",
-    "changelog_uri"     => "https://github.com/chef/chef/blob/master/CHANGELOG.md",
+    "changelog_uri"     => "https://github.com/chef/chef/blob/main/CHANGELOG.md",
     "documentation_uri" => "https://docs.chef.io/",
     "homepage_uri"      => "https://www.chef.io",
     "mailing_list_uri"  => "https://discourse.chef.io/",

data/lib/chef/knife/client_create.rb

@@ -54,6 +54,10 @@ class Chef
         @client_field ||= Chef::ApiClientV1.new
       end
 
+      def file
+        config[:file]
+      end
+
       def create_client(client)
         # should not be using save :( bad behavior
         Chef::ApiClientV1.from_hash(client).save
@@ -81,13 +85,7 @@ class Chef
           client.public_key File.read(File.expand_path(config[:public_key]))
         end
 
-        # Check the file before creating the client so the api is more transactional.
-        if config[:file]
-          file = config[:file]
-          dir_name = File.dirname(file)
-          check_writable_or_exists(dir_name, "Directory")
-          check_writable_or_exists(file, "File")
-        end
+        file_is_writable!
 
         output = edit_hash(client)
         final_client = create_client(output)
@@ -105,15 +103,35 @@ class Chef
         end
       end
 
-      # To check if file or directory exists or writable and raise exception accordingly
-      def check_writable_or_exists(file, type)
-        if File.exist?(file)
-          unless File.writable?(file)
-            ui.fatal "#{type} #{file} is not writable. Check permissions."
-            exit 1
-          end
-        else
-          ui.fatal "#{type} #{file} does not exist."
+      #
+      # This method is used to verify that the file and it's containing
+      # directory are writable.  This ensures that you don't create the client
+      # and then lose the private key because you weren't able to write it to
+      # disk.
+      #
+      # @return [void]
+      #
+      def file_is_writable!
+        return unless file
+
+        dir = File.dirname(File.expand_path(file))
+        unless File.exist?(dir)
+          ui.fatal "Directory #{dir} does not exist. Please create and retry."
+          exit 1
+        end
+
+        unless File.directory?(dir)
+          ui.fatal "#{dir} exists, but is not a directory. Please update your file path (--file #{file}) or re-create #{dir} as a directory."
+          exit 1
+        end
+
+        unless File.writable?(dir)
+          ui.fatal "Directory #{dir} is not writable. Please check the permissions."
+          exit 1
+        end
+
+        if File.exist?(file) && !File.writable?(file)
+          ui.fatal "File #{file} is not writable. Please check the permissions."
           exit 1
         end
       end

data/lib/chef/knife/cookbook_upload.rb

@@ -71,6 +71,11 @@ class Chef
         long: "--include-dependencies",
         description: "Also upload cookbook dependencies."
 
+      option :check_dependencies,
+        boolean: true, long: "--[no-]check-dependencies",
+        description: "Whether or not cookbook dependencies are verified before uploading cookbook(s) to #{ChefUtils::Dist::Server::PRODUCT}. You shouldn't disable this unless you really know what you're doing.",
+        default: true
+
       def run
         # Sanity check before we load anything from the server
         if ! config[:all] && @name_args.empty?
@@ -86,11 +91,6 @@ class Chef
         upload_failures = 0
         upload_ok = 0
 
-        # Get a list of cookbooks and their versions from the server
-        # to check for the existence of a cookbook's dependencies.
-        @server_side_cookbooks = Chef::CookbookVersion.list_all_versions
-        justify_width = @server_side_cookbooks.map(&:size).max.to_i + 2
-
         cookbooks = []
         cookbooks_to_upload.each do |cookbook_name, cookbook|
           raise Chef::Exceptions::MetadataNotFound.new(cookbook.root_paths[0], cookbook_name) unless cookbook.has_metadata_file?
@@ -120,7 +120,7 @@ class Chef
             if config[:all]
               if cookbooks_for_upload.any?
                 begin
-                  upload(cookbooks_for_upload, justify_width)
+                  upload(cookbooks_for_upload)
                 rescue Chef::Exceptions::CookbookFrozen
                   ui.warn("Not updating version constraints for some cookbooks in the environment as the cookbook is frozen.")
                   ui.error("Uploading of some of the cookbooks must be failed. Remove cookbook whose version is frozen from your cookbooks repo OR use --force option.")
@@ -133,7 +133,7 @@ class Chef
             else
               tmp_cl.each do |cookbook_name, cookbook|
 
-                upload([cookbook], justify_width)
+                upload([cookbook])
                 upload_ok += 1
               rescue Exceptions::CookbookNotFoundInRepo => e
                 upload_failures += 1
@@ -165,6 +165,27 @@ class Chef
         end
       end
 
+      def server_side_cookbooks
+        @server_side_cookbooks ||= Chef::CookbookVersion.list_all_versions
+      end
+
+      def justify_width
+        @justify_width ||= server_side_cookbooks.map(&:size).max.to_i + 2
+      end
+
+      #
+      # @param cookbook [Chef::CookbookVersion]
+      #
+      def left_justify_name(cookbook)
+        # We only want to lookup justify width value if we're already loading
+        # cookbooks to check dependencies exist in Chef Infra Server.
+        if config[:check_dependencies] == true
+          cookbook.name.to_s.ljust(justify_width + 10)
+        else
+          cookbook.name.to_s.ljust(24)
+        end
+      end
+
       def cookbooks_to_upload
         @cookbooks_to_upload ||=
           if config[:all]
@@ -220,11 +241,11 @@ class Chef
         end
       end
 
-      def upload(cookbooks, justify_width)
+      def upload(cookbooks)
         cookbooks.each do |cb|
-          ui.info("Uploading #{cb.name.to_s.ljust(justify_width + 10)} [#{cb.version}]")
+          ui.info("Uploading #{left_justify_name(cb)} [#{cb.version}]")
           check_for_broken_links!(cb)
-          check_for_dependencies!(cb)
+          check_for_dependencies!(cb) if config[:check_dependencies] == true
         end
         Chef::CookbookUploader.new(cookbooks, force: config[:force], concurrency: config[:concurrency]).upload_cookbooks
       rescue Chef::Exceptions::CookbookFrozen => e
@@ -265,12 +286,12 @@ class Chef
       end
 
       def check_server_side_cookbooks(cookbook_name, version)
-        if @server_side_cookbooks[cookbook_name].nil?
+        if server_side_cookbooks[cookbook_name].nil?
           false
         else
-          versions = @server_side_cookbooks[cookbook_name]["versions"].collect { |versions| versions["version"] }
+          versions = server_side_cookbooks[cookbook_name]["versions"].collect { |versions| versions["version"] }
           Log.debug "Versions of cookbook '#{cookbook_name}' returned by the server: #{versions.join(", ")}"
-          @server_side_cookbooks[cookbook_name]["versions"].each do |versions_hash|
+          server_side_cookbooks[cookbook_name]["versions"].each do |versions_hash|
             if Chef::VersionConstraint.new(version).include?(versions_hash["version"])
               Log.debug "Matched cookbook '#{cookbook_name}' with constraint '#{version}' to cookbook version '#{versions_hash["version"]}' on the server"
               return true

data/lib/chef/knife/version.rb

@@ -17,7 +17,7 @@
 class Chef
   class Knife
     KNIFE_ROOT = File.expand_path("../..", __dir__)
-    VERSION = "17.4.18".freeze
+    VERSION = "17.4.46".freeze
   end
 end
 

data/spec/integration/client_create_spec.rb

@@ -50,7 +50,6 @@ describe "knife client create", :workstation do
 
     it "saves the private key to a file" do
       Dir.mktmpdir do |tgt|
-        File.open("#{tgt}/bah.pem", "w") { |pub| pub.write("test key") }
         knife("client create -f #{tgt}/bah.pem bah").should_succeed stderr: out
         expect(File).to exist("#{tgt}/bah.pem")
       end

data/spec/unit/knife/client_create_spec.rb

@@ -54,6 +54,19 @@ describe Chef::Knife::ClientCreate do
     Chef::Config[:node_name] = "webmonkey.example.com"
   end
 
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:file_path) { File.join(tmpdir, "client.pem") }
+  let(:dir_path) { File.dirname(file_path) }
+
+  before do
+    allow(File).to receive(:exist?).and_call_original
+    allow(File).to receive(:exist?).with(file_path).and_return(false)
+    allow(File).to receive(:exist?).with(dir_path).and_return(true)
+    allow(File).to receive(:directory?).with(dir_path).and_return(true)
+    allow(File).to receive(:writable?).with(file_path).and_return(true)
+    allow(File).to receive(:writable?).with(dir_path).and_return(true)
+  end
+
   describe "run" do
     context "when nothing is passed" do
       # from spec/support/shared/unit/knife_shared.rb
@@ -118,18 +131,66 @@ describe Chef::Knife::ClientCreate do
 
       describe "with -f or --file" do
         before do
+          knife.config[:file] = file_path
           client.private_key "woot"
         end
 
         it "should write the private key to a file" do
-          file = Tempfile.new
-          file_path = file.path
-          knife.config[:file] = file_path
           filehandle = double("Filehandle")
           expect(filehandle).to receive(:print).with("woot")
           expect(File).to receive(:open).with(file_path, "w").and_yield(filehandle)
           knife.run
         end
+
+        context "when the directory does not exist" do
+          before { allow(File).to receive(:exist?).with(dir_path).and_return(false) }
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("Directory #{dir_path} does not exist. Please create and retry.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
+
+        context "when the directory is not writable" do
+          before { allow(File).to receive(:writable?).with(dir_path).and_return(false) }
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("Directory #{dir_path} is not writable. Please check the permissions.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
+
+        context "when the directory is a file" do
+          before { allow(File).to receive(:directory?).with(dir_path).and_return(false) }
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("#{dir_path} exists, but is not a directory. Please update your file path (--file #{file_path}) or re-create #{dir_path} as a directory.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
+
+        context "when the file does not exist" do
+          before do
+            allow(File).to receive(:exist?).with(file_path).and_return(false)
+          end
+
+          it "does not log a fatal message and does not raise exception" do
+            expect(knife.ui).not_to receive(:fatal)
+            expect { knife.run }.not_to raise_error
+          end
+        end
+
+        context "when the file exists and is not writable" do
+          before do
+            allow(File).to receive(:exist?).with(file_path).and_return(true)
+            allow(File).to receive(:writable?).with(file_path).and_return(false)
+          end
+
+          it "writes a fatal message and exits 1" do
+            expect(knife.ui).to receive(:fatal).with("File #{file_path} is not writable. Please check the permissions.")
+            expect { knife.run }.to raise_error(SystemExit)
+          end
+        end
       end
 
       describe "with -p or --public-key" do
@@ -166,39 +227,6 @@ describe Chef::Knife::ClientCreate do
           expect(client.validator).to be_truthy
         end
       end
-
-      describe "with -f or --file when dir or file is not writable or does not exists" do
-        let(:dir_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "knife", "temp_dir")) }
-        let(:file_path) { File.expand_path(File.join(dir_path, "tmp.pem")) }
-
-        it "when the directory does not exists" do
-          knife.config[:file] = "example/client1.pem"
-          expect(knife.ui).to receive(:fatal).with("Directory example does not exist.")
-          expect { knife.run }.to raise_error(SystemExit)
-        end
-
-        it "when the directory not writable" do
-          knife.config[:file] = file_path
-          File.chmod(777, dir_path)
-          expect(knife.ui).to receive(:fatal).with("Directory #{dir_path} is not writable. Check permissions.")
-          expect { knife.run }.to raise_error(SystemExit)
-        end
-
-        it "when the file does not exists" do
-          path = "#{dir_path}/client1.pem"
-          knife.config[:file] = path
-          File.chmod(0755, dir_path)
-          expect(knife.ui).to receive(:fatal).with("File #{path} does not exist.")
-          expect { knife.run }.to raise_error(SystemExit)
-        end
-
-        it "when the file is not writable" do
-          knife.config[:file] = file_path
-          File.chmod(777, file_path)
-          expect(knife.ui).to receive(:fatal).with("File #{file_path} is not writable. Check permissions.")
-          expect { knife.run }.to raise_error(SystemExit)
-        end
-      end
     end
   end
 end

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -60,11 +60,12 @@ describe Chef::Knife::CookbookUpload do
   before(:each) do
     allow(Chef::CookbookLoader).to receive(:new).and_return(cookbook_loader)
     allow(Chef::CookbookLoader).to receive(:copy_to_tmp_dir_from_array).and_yield(cookbook_loader)
+    allow(Chef::CookbookVersion).to receive(:list).and_return({})
+    allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
   end
 
   describe "with --concurrency" do
     it "should upload cookbooks with predefined concurrency" do
-      allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
       knife.config[:concurrency] = 3
       test_cookbook = Chef::CookbookVersion.new("test_cookbook", "/tmp/blah")
       allow(cookbook_loader).to receive(:each).and_yield("test_cookbook", test_cookbook)
@@ -79,7 +80,6 @@ describe Chef::Knife::CookbookUpload do
   describe "run" do
     before(:each) do
       allow(Chef::CookbookUploader).to receive_messages(new: cookbook_uploader)
-      allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
     end
 
     it "should print usage and exit when a cookbook name is not provided" do
@@ -214,48 +214,110 @@ describe Chef::Knife::CookbookUpload do
       end
     end
 
-    describe "when specifying a cookbook name with missing dependencies" do
-      let(:cookbook_dependency) { Chef::CookbookVersion.new("dependency", "/tmp/blah") }
+    context "when chef_dependencies config is disabled" do
+      before do
+        knife.config[:check_dependencies] = false
+      end
 
-      before(:each) do
-        cookbook.metadata.depends("dependency")
-        allow(cookbook_loader).to receive(:[]) do |ckbk|
-          { "test_cookbook" => cookbook,
-            "dependency" => cookbook_dependency }[ckbk]
+      describe "when specifying a cookbook name with missing dependencies" do
+        let(:cookbook_dependency) { Chef::CookbookVersion.new("dependency", "/tmp/blah") }
+
+        before(:each) do
+          cookbook.metadata.depends("dependency")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{cookbook_dependency test_cookbook})
+          @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+          knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
         end
-        allow(knife).to receive(:cookbook_names).and_return(%w{cookbook_dependency test_cookbook})
-        @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
-        knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
-      end
 
-      it "should exit and not upload the cookbook" do
-        expect(cookbook_loader).to receive(:[]).once.with("test_cookbook")
-        expect(cookbook_uploader).not_to receive(:upload_cookbooks)
-        expect { knife.run }.to raise_error(SystemExit)
+        it "should not fetch all cookbooks from Chef Infra Server" do
+          expect(Chef::CookbookVersion).not_to receive(:list_all_versions)
+          knife.run
+        end
+
+        it "should upload the cookbook" do
+          expect(cookbook_loader).to receive(:[]).once.with("test_cookbook")
+          expect(cookbook_uploader).to receive(:upload_cookbooks)
+          knife.run
+        end
+
+        it "should not output a message for a single missing dependency" do
+          knife.run
+          expect(@stderr.string).not_to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).not_to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).not_to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+        end
+
+        it "should not output a message for a multiple missing dependencies which are concatenated" do
+          cookbook_dependency2 = Chef::CookbookVersion.new("dependency2")
+          cookbook.metadata.depends("dependency2")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency,
+              "dependency2" => cookbook_dependency2 }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{dependency dependency2 test_cookbook})
+          knife.run
+          expect(@stderr.string).not_to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).not_to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).not_to include("The missing cookbook(s) are:")
+          expect(@stderr.string).not_to include("'dependency' version '>= 0.0.0'")
+          expect(@stderr.string).not_to include("'dependency2' version '>= 0.0.0'")
+        end
       end
+    end
 
-      it "should output a message for a single missing dependency" do
-        expect { knife.run }.to raise_error(SystemExit)
-        expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
-        expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
-        expect(@stderr.string).to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+    context "when chef_dependencies config is enabled" do
+      before do
+        knife.config[:check_dependencies] = true
       end
 
-      it "should output a message for a multiple missing dependencies which are concatenated" do
-        cookbook_dependency2 = Chef::CookbookVersion.new("dependency2")
-        cookbook.metadata.depends("dependency2")
-        allow(cookbook_loader).to receive(:[]) do |ckbk|
-          { "test_cookbook" => cookbook,
-            "dependency" => cookbook_dependency,
-            "dependency2" => cookbook_dependency2 }[ckbk]
+      describe "when specifying a cookbook name with missing dependencies" do
+        let(:cookbook_dependency) { Chef::CookbookVersion.new("dependency", "/tmp/blah") }
+
+        before(:each) do
+          cookbook.metadata.depends("dependency")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{cookbook_dependency test_cookbook})
+          @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+          knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+        end
+
+        it "should exit and not upload the cookbook" do
+          expect(cookbook_loader).to receive(:[]).once.with("test_cookbook")
+          expect(cookbook_uploader).not_to receive(:upload_cookbooks)
+          expect { knife.run }.to raise_error(SystemExit)
+        end
+
+        it "should output a message for a single missing dependency" do
+          expect { knife.run }.to raise_error(SystemExit)
+          expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+        end
+
+        it "should output a message for a multiple missing dependencies which are concatenated" do
+          cookbook_dependency2 = Chef::CookbookVersion.new("dependency2")
+          cookbook.metadata.depends("dependency2")
+          allow(cookbook_loader).to receive(:[]) do |ckbk|
+            { "test_cookbook" => cookbook,
+              "dependency" => cookbook_dependency,
+              "dependency2" => cookbook_dependency2 }[ckbk]
+          end
+          allow(knife).to receive(:cookbook_names).and_return(%w{dependency dependency2 test_cookbook})
+          expect { knife.run }.to raise_error(SystemExit)
+          expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
+          expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
+          expect(@stderr.string).to include("The missing cookbook(s) are:")
+          expect(@stderr.string).to include("'dependency' version '>= 0.0.0'")
+          expect(@stderr.string).to include("'dependency2' version '>= 0.0.0'")
         end
-        allow(knife).to receive(:cookbook_names).and_return(%w{dependency dependency2 test_cookbook})
-        expect { knife.run }.to raise_error(SystemExit)
-        expect(@stderr.string).to include("Cookbook test_cookbook depends on cookbooks which are not currently")
-        expect(@stderr.string).to include("being uploaded and cannot be found on the server.")
-        expect(@stderr.string).to include("The missing cookbook(s) are:")
-        expect(@stderr.string).to include("'dependency' version '>= 0.0.0'")
-        expect(@stderr.string).to include("'dependency2' version '>= 0.0.0'")
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife
 version: !ruby/object:Gem::Version
-  version: 17.4.18
+  version: 17.4.46
 platform: ruby
 authors:
 - Adam Jacob
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-02 00:00:00.000000000 Z
+date: 2021-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-config
@@ -256,6 +256,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: x25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.9
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
@@ -1130,7 +1144,7 @@ licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/chef/chef/issues
-  changelog_uri: https://github.com/chef/chef/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/chef/chef/blob/main/CHANGELOG.md
   documentation_uri: https://docs.chef.io/
   homepage_uri: https://www.chef.io
   mailing_list_uri: https://discourse.chef.io/