knife 17.0.246 → 17.2.18

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

@@ -0,0 +1,187 @@
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# 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/cookbook_scm_repo"
+
+describe Chef::Knife::CookbookSCMRepo do
+  before do
+    @repo_path = File.join(CHEF_SPEC_DATA, "cookbooks")
+    @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
+    @ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+    @cookbook_repo = Chef::Knife::CookbookSCMRepo.new(@repo_path, @ui, default_branch: "master")
+
+    @branch_list = Mixlib::ShellOut.new
+    @branch_list.stdout.replace(<<-BRANCHES)
+  chef-vendor-apache2
+  chef-vendor-build-essential
+  chef-vendor-dynomite
+  chef-vendor-ganglia
+  chef-vendor-graphite
+  chef-vendor-python
+  chef-vendor-absent-new
+    BRANCHES
+  end
+
+  it "has a path to the cookbook repo" do
+    expect(@cookbook_repo.repo_path).to eq(@repo_path)
+  end
+
+  it "has a default branch" do
+    expect(@cookbook_repo.default_branch).to eq("master")
+  end
+
+  describe "when sanity checking the repo" do
+    it "exits when the directory does not exist" do
+      expect(::File).to receive(:directory?).with(@repo_path).and_return(false)
+      expect { @cookbook_repo.sanity_check }.to raise_error(SystemExit)
+    end
+
+    describe "and the repo dir exists" do
+      before do
+        allow(::File).to receive(:directory?).with(@repo_path).and_return(true)
+      end
+
+      it "exits when there is no git repo" do
+        allow(::File).to receive(:directory?).with(/.*\.git/).and_return(false)
+        expect { @cookbook_repo.sanity_check }.to raise_error(SystemExit)
+      end
+
+      describe "and the repo is a git repo" do
+        before do
+          allow(::File).to receive(:directory?).with(File.join(@repo_path, ".git")).and_return(true)
+        end
+
+        it "exits when the default branch doesn't exist" do
+          @nobranches = Mixlib::ShellOut.new.tap { |s| s.stdout.replace "\n" }
+          expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@nobranches)
+          expect { @cookbook_repo.sanity_check }.to raise_error(SystemExit)
+        end
+
+        describe "and the default branch exists" do
+          before do
+            @master_branch = Mixlib::ShellOut.new
+            @master_branch.stdout.replace "* master\n"
+            expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@master_branch)
+          end
+
+          it "exits when the git repo is dirty" do
+            @dirty_status = Mixlib::ShellOut.new
+            @dirty_status.stdout.replace(<<-DIRTY)
+ M chef/lib/chef/knife/cookbook_site_install.rb
+            DIRTY
+            expect(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain", cwd: @repo_path).and_return(@dirty_status)
+            expect { @cookbook_repo.sanity_check }.to raise_error(SystemExit)
+          end
+
+          describe "and the repo is clean" do
+            before do
+              @clean_status = Mixlib::ShellOut.new.tap { |s| s.stdout.replace("\n") }
+              allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain", cwd: @repo_path).and_return(@clean_status)
+            end
+
+            it "passes the sanity check" do
+              @cookbook_repo.sanity_check
+            end
+
+          end
+        end
+      end
+    end
+  end
+
+  it "resets to default state by checking out the default branch" do
+    expect(@cookbook_repo).to receive(:shell_out!).with("git checkout master", cwd: @repo_path)
+    @cookbook_repo.reset_to_default_state
+  end
+
+  it "determines if a the pristine copy branch exists" do
+    expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+    expect(@cookbook_repo.branch_exists?("chef-vendor-apache2")).to be_truthy
+    expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+    expect(@cookbook_repo.branch_exists?("chef-vendor-nginx")).to be_falsey
+  end
+
+  it "determines if a the branch not exists correctly without substring search" do
+    expect(@cookbook_repo).to receive(:shell_out!).twice.with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+    expect(@cookbook_repo).not_to be_branch_exists("chef-vendor-absent")
+    expect(@cookbook_repo).to be_branch_exists("chef-vendor-absent-new")
+  end
+
+  describe "when the pristine copy branch does not exist" do
+    it "prepares for import by creating the pristine copy branch" do
+      expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout -b chef-vendor-nginx", cwd: @repo_path)
+      @cookbook_repo.prepare_to_import("nginx")
+    end
+  end
+
+  describe "when the pristine copy branch does exist" do
+    it "prepares for import by checking out the pristine copy branch" do
+      expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", cwd: @repo_path).and_return(@branch_list)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout chef-vendor-apache2", cwd: @repo_path)
+      @cookbook_repo.prepare_to_import("apache2")
+    end
+  end
+
+  describe "when the pristine copy branch was not updated by the changes" do
+    before do
+      @updates = Mixlib::ShellOut.new
+      @updates.stdout.replace("\n")
+      allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain -- apache2", cwd: @repo_path).and_return(@updates)
+    end
+
+    it "shows no changes in the pristine copy" do
+      expect(@cookbook_repo.updated?("apache2")).to be_falsey
+    end
+
+    it "does nothing to finalize the updates" do
+      expect(@cookbook_repo.finalize_updates_to("apache2", "1.2.3")).to be_falsey
+    end
+  end
+
+  describe "when the pristine copy branch was updated by the changes" do
+    before do
+      @updates = Mixlib::ShellOut.new
+      @updates.stdout.replace(" M cookbooks/apache2/recipes/default.rb\n")
+      allow(@cookbook_repo).to receive(:shell_out!).with("git status --porcelain -- apache2", cwd: @repo_path).and_return(@updates)
+    end
+
+    it "shows changes in the pristine copy" do
+      expect(@cookbook_repo.updated?("apache2")).to be_truthy
+    end
+
+    it "commits the changes to the repo and tags the commit" do
+      expect(@cookbook_repo).to receive(:shell_out!).with("git add apache2", cwd: @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git commit -m \"Import apache2 version 1.2.3\" -- apache2", cwd: @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with("git tag -f cookbook-site-imported-apache2-1.2.3", cwd: @repo_path)
+      expect(@cookbook_repo.finalize_updates_to("apache2", "1.2.3")).to be_truthy
+    end
+  end
+
+  describe "when a custom default branch is specified" do
+    before do
+      @cookbook_repo = Chef::Knife::CookbookSCMRepo.new(@repo_path, @ui, default_branch: "develop")
+    end
+
+    it "resets to default state by checking out the default branch" do
+      expect(@cookbook_repo).to receive(:shell_out!).with("git checkout develop", cwd: @repo_path)
+      @cookbook_repo.reset_to_default_state
+    end
+  end
+end

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

@@ -0,0 +1,198 @@
+#
+# Author:: Xabier de Zuazo (xabier@onddo.com)
+# Copyright:: Copyright 2013-2016, Onddo Labs, SL.
+# 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/cookbook_site_streaming_uploader"
+
+class FakeTempfile
+  def initialize(basename)
+    @basename = basename
+  end
+
+  def close; end
+
+  def path
+    "#{@basename}.ZZZ"
+  end
+
+end
+
+describe Chef::Knife::Core::CookbookSiteStreamingUploader do
+
+  let(:subject) { Chef::Knife::Core::CookbookSiteStreamingUploader }
+  describe "create_build_dir" do
+    before(:each) do
+      @cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))
+      @loader = Chef::CookbookLoader.new(@cookbook_repo)
+      @loader.load_cookbooks
+      allow(File).to receive(:unlink)
+    end
+
+    it "should create the cookbook tmp dir" do
+      cookbook = @loader[:openldap]
+      files_count = Dir.glob(File.join(@cookbook_repo, cookbook.name.to_s, "**", "*"), File::FNM_DOTMATCH).count { |file| File.file?(file) }
+
+      expect(Tempfile).to receive(:new).with("chef-#{cookbook.name}-build").and_return(FakeTempfile.new("chef-#{cookbook.name}-build"))
+      expect(FileUtils).to receive(:mkdir_p).exactly(files_count + 1).times
+      expect(FileUtils).to receive(:cp).exactly(files_count).times
+      subject.create_build_dir(cookbook)
+    end
+
+  end # create_build_dir
+
+  describe "make_request" do
+
+    before(:each) do
+      @uri = "http://cookbooks.dummy.com/api/v1/cookbooks"
+      @secret_filename = File.join(CHEF_SPEC_DATA, "ssl/private_key.pem")
+      @rsa_key = File.read(@secret_filename)
+      response = Net::HTTPResponse.new("1.0", "200", "OK")
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_return(response)
+    end
+
+    it "should send an http request" do
+      expect_any_instance_of(Net::HTTP).to receive(:request)
+      subject.make_request(:post, @uri, "bill", @secret_filename)
+    end
+
+    it "should read the private key file" do
+      expect(File).to receive(:read).with(@secret_filename).and_return(@rsa_key)
+      subject.make_request(:post, @uri, "bill", @secret_filename)
+    end
+
+    it "should add the authentication signed header" do
+      expect_any_instance_of(Mixlib::Authentication::SigningObject).to receive(:sign).and_return({})
+      subject.make_request(:post, @uri, "bill", @secret_filename)
+    end
+
+    it "should be able to send post requests" do
+      post = Net::HTTP::Post.new(@uri, {})
+
+      expect(Net::HTTP::Post).to receive(:new).once.and_return(post)
+      expect(Net::HTTP::Put).not_to receive(:new)
+      expect(Net::HTTP::Get).not_to receive(:new)
+      subject.make_request(:post, @uri, "bill", @secret_filename)
+    end
+
+    it "should be able to send put requests" do
+      put = Net::HTTP::Put.new(@uri, {})
+
+      expect(Net::HTTP::Post).not_to receive(:new)
+      expect(Net::HTTP::Put).to receive(:new).once.and_return(put)
+      expect(Net::HTTP::Get).not_to receive(:new)
+      subject.make_request(:put, @uri, "bill", @secret_filename)
+    end
+
+    it "should be able to receive files to attach as argument" do
+      subject.make_request(:put, @uri, "bill", @secret_filename, {
+        myfile: File.new(File.join(CHEF_SPEC_DATA, "config.rb")), # a dummy file
+      })
+    end
+
+    it "should be able to receive strings to attach as argument" do
+      subject.make_request(:put, @uri, "bill", @secret_filename, {
+        mystring: "Lorem ipsum",
+      })
+    end
+
+    it "should be able to receive strings and files as argument at the same time" do
+      subject.make_request(:put, @uri, "bill", @secret_filename, {
+        myfile1: File.new(File.join(CHEF_SPEC_DATA, "config.rb")),
+        mystring1: "Lorem ipsum",
+        myfile2: File.new(File.join(CHEF_SPEC_DATA, "config.rb")),
+        mystring2: "Dummy text",
+      })
+    end
+
+  end # make_request
+
+  describe "StreamPart" do
+    before(:each) do
+      @file = File.new(File.join(CHEF_SPEC_DATA, "config.rb"))
+      @stream_part = Chef::Knife::Core::CookbookSiteStreamingUploader::StreamPart.new(@file, File.size(@file))
+    end
+
+    it "should create a StreamPart" do
+      expect(@stream_part).to be_instance_of(Chef::Knife::Core::CookbookSiteStreamingUploader::StreamPart)
+    end
+
+    it "should expose its size" do
+      expect(@stream_part.size).to eql(File.size(@file))
+    end
+
+    it "should read with offset and how_much" do
+      content = @file.read(4)
+      @file.rewind
+      expect(@stream_part.read(0, 4)).to eql(content)
+    end
+
+  end # StreamPart
+
+  describe "StringPart" do
+    before(:each) do
+      @str = "What a boring string"
+      @string_part = Chef::Knife::Core::CookbookSiteStreamingUploader::StringPart.new(@str)
+    end
+
+    it "should create a StringPart" do
+      expect(@string_part).to be_instance_of(Chef::Knife::Core::CookbookSiteStreamingUploader::StringPart)
+    end
+
+    it "should expose its size" do
+      expect(@string_part.size).to eql(@str.size)
+    end
+
+    it "should read with offset and how_much" do
+      expect(@string_part.read(2, 4)).to eql(@str[2, 4])
+    end
+
+  end # StringPart
+
+  describe "MultipartStream" do
+    before(:each) do
+      @string1 = "stream1"
+      @string2 = "stream2"
+      @stream1 = Chef::Knife::Core::CookbookSiteStreamingUploader::StringPart.new(@string1)
+      @stream2 = Chef::Knife::Core::CookbookSiteStreamingUploader::StringPart.new(@string2)
+      @parts = [ @stream1, @stream2 ]
+
+      @multipart_stream = Chef::Knife::Core::CookbookSiteStreamingUploader::MultipartStream.new(@parts)
+    end
+
+    it "should create a MultipartStream" do
+      expect(@multipart_stream).to be_instance_of(Chef::Knife::Core::CookbookSiteStreamingUploader::MultipartStream)
+    end
+
+    it "should expose its size" do
+      expect(@multipart_stream.size).to eql(@stream1.size + @stream2.size)
+    end
+
+    it "should read with how_much" do
+      expect(@multipart_stream.read(10)).to eql("#{@string1}#{@string2}"[0, 10])
+    end
+
+    it "should read receiving destination buffer as second argument (CHEF-4456: Ruby 2 compat)" do
+      dst_buf = ""
+      @multipart_stream.read(10, dst_buf)
+      expect(dst_buf).to eql("#{@string1}#{@string2}"[0, 10])
+    end
+
+  end # MultipartStream
+
+end

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

@@ -0,0 +1,242 @@
+#
+# 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"
+
+describe Chef::Knife::SubcommandLoader::GemGlobLoader do
+  let(:loader) { Chef::Knife::SubcommandLoader::GemGlobLoader.new(File.join(CHEF_SPEC_DATA, "knife-site-subcommands")) }
+  let(:home) { File.join(CHEF_SPEC_DATA, "knife-home") }
+  let(:plugin_dir) { File.join(home, ".chef", "plugins", "knife") }
+
+  before do
+    allow(ChefUtils).to receive(:windows?) { false }
+    ChefConfig::PathHelper.class_variable_set(:@@home_dir, home)
+  end
+
+  after do
+    ChefConfig::PathHelper.class_variable_set(:@@home_dir, nil)
+  end
+
+  it "builds a list of the core subcommand file require paths" do
+    expect(loader.subcommand_files).not_to be_empty
+    loader.subcommand_files.each do |require_path|
+      expect(require_path).to match(%r{chef/knife/.*|plugins/knife/.*})
+    end
+  end
+
+  it "finds files installed via rubygems" do
+    expect(loader.find_subcommands_via_rubygems).to include("chef/knife/node_create")
+    loader.find_subcommands_via_rubygems.each_value { |abs_path| expect(abs_path).to match(%r{chef/knife/.+}) }
+  end
+
+  it "finds files from latest version of installed gems" do
+    gems = [ double("knife-ec2-0.5.12") ]
+    gem_files = [
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_base.rb",
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_otherstuff.rb",
+    ]
+    expect($LOAD_PATH).to receive(:map).and_return([])
+    if Gem::Specification.respond_to? :latest_specs
+      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return(gems)
+      expect(gems[0]).to receive(:matches_for_glob).with(%r{chef/knife/\*\.rb\{(.*),\.rb,(.*)\}}).and_return(gem_files)
+    else
+      expect(Gem.source_index).to receive(:latest_specs).with(true).and_return(gems)
+      expect(gems[0]).to receive(:require_paths).twice.and_return(["lib"])
+      expect(gems[0]).to receive(:full_gem_path).and_return("/usr/lib/ruby/gems/knife-ec2-0.5.12")
+      expect(Dir).to receive(:[]).with("/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb").and_return(gem_files)
+    end
+    expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
+    expect(loader.subcommand_files.select { |file| file.include?("knife-ec2") }.sort).to eq(gem_files)
+  end
+  it "excludes knife version file if loaded from a gem" do
+    gems = [ double("knife-ec2-0.5.12") ]
+    gem_files = [
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_base.rb",
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_otherstuff.rb",
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/version.rb",
+    ]
+    expected_files = [
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_base.rb",
+      "/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_otherstuff.rb",
+    ]
+
+    expect($LOAD_PATH).to receive(:map).and_return([])
+    if Gem::Specification.respond_to? :latest_specs
+      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return(gems)
+      expect(gems[0]).to receive(:matches_for_glob).with(%r{chef/knife/\*\.rb\{(.*),\.rb,(.*)\}}).and_return(gem_files)
+    else
+      expect(Gem.source_index).to receive(:latest_specs).with(true).and_return(gems)
+      expect(gems[0]).to receive(:require_paths).twice.and_return(["lib"])
+      expect(gems[0]).to receive(:full_gem_path).and_return("/usr/lib/ruby/gems/knife-ec2-0.5.12")
+      expect(Dir).to receive(:[]).with("/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb").and_return(gem_files)
+    end
+    expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
+    expect(loader.subcommand_files.select { |file| file.include?("knife-ec2") }.sort).to eq(expected_files)
+  end
+
+  it "finds files using a dirglob when rubygems is not available" do
+    expect(loader.find_subcommands_via_dirglob).to include("chef/knife/node_create")
+    loader.find_subcommands_via_dirglob.each_value { |abs_path| expect(abs_path).to match(%r{chef/knife/.+}) }
+  end
+
+  it "excludes chef/knife/version.rb using a dirglob when rubygems is not available" do
+    expect(loader.find_subcommands_via_dirglob).to_not include("chef/knife/version")
+    loader.find_subcommands_via_dirglob.each_value { |abs_path| expect(abs_path).to match(%r{chef/knife/.+}) }
+  end
+
+  it "finds user-specific subcommands in the user's ~/.chef directory" do
+    expected_command = File.join(home, ".chef", "plugins", "knife", "example_home_subcommand.rb")
+    expect(loader.site_subcommands).to include(expected_command)
+  end
+
+  it "finds repo specific subcommands by searching for a .chef directory" do
+    expected_command = File.join(CHEF_SPEC_DATA, "knife-site-subcommands", "plugins", "knife", "example_subcommand.rb")
+    expect(loader.site_subcommands).to include(expected_command)
+  end
+
+  # https://github.com/chef/chef-dk/issues/227
+  #
+  # `knife` in ChefDK isn't from a gem install, it's directly run from a clone
+  # of the source, but there can be one or more versions of chef also installed
+  # as a gem. If the gem install contains a command that doesn't exist in the
+  # source tree of the "primary" chef install, it can be loaded and cause an
+  # error. We also want to ensure that we only load builtin commands from the
+  # "primary" chef install.
+  #
+  # NOTE - we need to revisit coverage now that we're moving knife to its own gem;
+  # or remove this test if it's no longer a supported scenario.
+  context "when a different version of chef is also installed as a gem" do
+
+    let(:all_found_commands) do
+      [
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/bootstrap.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_bulk_delete.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_create.rb",
+
+        # We use the fake version 1.0.0 because that version doesn't exist,
+        # which ensures it won't ever equal "chef-#{Chef::VERSION}"
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/bootstrap.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/client_bulk_delete.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/client_create.rb",
+
+        # Test that we don't accept a version number that is different only in
+        # trailing characters, e.g. we are running Chef 12.0.0 but there is a
+        # Chef 12.0.0.rc.0 gem also:
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.rc.0/lib/chef/knife/thing.rb",
+
+        # Test that we ignore the platform suffix when checking for different
+        # gem versions.
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-x86-mingw32/lib/chef/knife/valid.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-i386-mingw64/lib/chef/knife/valid-too.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-mswin32/lib/chef/knife/also-valid.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-universal-mingw32/lib/chef/knife/universal-is-valid.rb",
+        # ...but don't ignore the .rc / .dev parts in the case when we have
+        # platform suffixes
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.rc.0-x86-mingw32/lib/chef/knife/invalid.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.dev-mswin32/lib/chef/knife/invalid-too.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}.dev.0-x86-mingw64/lib/chef/knife/still-invalid.rb",
+
+        # This command is "extra" compared to what's in the embedded/apps/chef install:
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-1.0.0/lib/chef/knife/data_bag_secret_options.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-vault-2.2.4/lib/chef/knife/decrypt.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/knife-spork-1.4.1/lib/chef/knife/spork-bump.rb",
+
+        # These are fake commands that have names designed to test that the
+        # regex is strict enough
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-foo-#{Chef::VERSION}/lib/chef/knife/chef-foo.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/foo-chef-#{Chef::VERSION}/lib/chef/knife/foo-chef.rb",
+
+        # In a real scenario, we'd use rubygems APIs to only select the most
+        # recent gem, but for this test we want to check that we're doing the
+        # right thing both when the plugin version matches and does not match
+        # the current chef version. Looking at
+        # `SubcommandLoader::MATCHES_THIS_CHEF_GEM` and
+        # `SubcommandLoader::MATCHES_CHEF_GEM` should make it clear why we want
+        # to test these two cases.
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-bar-1.0.0/lib/chef/knife/chef-bar.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/bar-chef-1.0.0/lib/chef/knife/bar-chef.rb",
+      ]
+    end
+
+    let(:expected_valid_commands) do
+      [
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/bootstrap.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_bulk_delete.rb",
+        "/opt/chefdk/embedded/apps/chef/lib/chef/knife/client_create.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-x86-mingw32/lib/chef/knife/valid.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-i386-mingw64/lib/chef/knife/valid-too.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-mswin32/lib/chef/knife/also-valid.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-#{Chef::VERSION}-universal-mingw32/lib/chef/knife/universal-is-valid.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-vault-2.2.4/lib/chef/knife/decrypt.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/knife-spork-1.4.1/lib/chef/knife/spork-bump.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-foo-#{Chef::VERSION}/lib/chef/knife/chef-foo.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/foo-chef-#{Chef::VERSION}/lib/chef/knife/foo-chef.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/chef-bar-1.0.0/lib/chef/knife/chef-bar.rb",
+        "/opt/chefdk/embedded/lib/ruby/gems/2.1.0/gems/bar-chef-1.0.0/lib/chef/knife/bar-chef.rb",
+      ]
+    end
+
+    before do
+      expect(loader).to receive(:find_files_latest_gems).with("chef/knife/*.rb").and_return(all_found_commands)
+      expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
+    end
+
+    it "ignores commands from the non-matching gem install" do
+      expect(loader.find_subcommands_via_rubygems.values).to eq(expected_valid_commands)
+    end
+
+  end
+
+  describe "finding 3rd party plugins" do
+    let(:env_home) { "/home/alice" }
+    let(:manifest_path) { env_home + "/.chef/plugin_manifest.json" }
+
+    before do
+      env_dup = ENV.to_hash
+      allow(ENV).to receive(:[]) { |key| env_dup[key] }
+      allow(ENV).to receive(:[]).with("HOME").and_return(env_home)
+    end
+
+    it "searches rubygems for plugins" do
+      if Gem::Specification.respond_to?(:latest_specs)
+        expect(Gem::Specification).to receive(:latest_specs).and_call_original
+      else
+        expect(Gem.source_index).to receive(:latest_specs).and_call_original
+      end
+      loader.subcommand_files.each do |require_path|
+        expect(require_path).to match(%r{chef/knife/.*|plugins/knife/.*})
+      end
+    end
+
+    context "and HOME environment variable is not set" do
+      before do
+        allow(ENV).to receive(:[]).with("HOME").and_return(nil)
+      end
+
+      it "searches rubygems for plugins" do
+        if Gem::Specification.respond_to?(:latest_specs)
+          expect(Gem::Specification).to receive(:latest_specs).and_call_original
+        else
+          expect(Gem.source_index).to receive(:latest_specs).and_call_original
+        end
+        loader.subcommand_files.each do |require_path|
+          expect(require_path).to match(%r{chef/knife/.*|plugins/knife/.*})
+        end
+      end
+    end
+  end
+end