chef 12.0.3 → 12.1.0.rc.0

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

@@ -39,18 +39,18 @@ describe Chef::Knife::Core::BootstrapContext do
   end
 
   it "runs chef with the first-boot.json in the _default environment" do
-    bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -E _default"
+    expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json -E _default"
   end
 
   describe "when in verbosity mode" do
     let(:config) { {:verbosity => 2} }
     it "adds '-l debug' when verbosity is >= 2" do
-      bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -l debug -E _default"
+      expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json -l debug -E _default"
     end
   end
 
   it "reads the validation key" do
-    bootstrap_context.validation_key.should eq IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'))
+    expect(bootstrap_context.validation_key).to eq IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem'))
   end
 
   it "generates the config file data" do
@@ -60,7 +60,7 @@ chef_server_url  "http://chef.example.com:4444"
 validation_client_name "chef-validator-testing"
 # Using default node name (fqdn)
 EXPECTED
-    bootstrap_context.config_content.should eq expected
+    expect(bootstrap_context.config_content).to eq expected
   end
 
   it "does not set a default log_level" do
@@ -70,14 +70,15 @@ EXPECTED
   describe "alternate chef-client path" do
     let(:chef_config){ {:chef_client_path => '/usr/local/bin/chef-client'} }
     it "runs chef-client from another path when specified" do
-      bootstrap_context.start_chef.should eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default"
+      expect(bootstrap_context.start_chef).to eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default"
     end
   end
 
   describe "validation key path that contains a ~" do
     let(:chef_config){ {:validation_key => '~/my.key'} }
     it "reads the validation key when it contains a ~" do
-      IO.should_receive(:read).with(File.expand_path("my.key", ENV['HOME']))
+      expect(File).to receive(:exist?).with(File.expand_path("my.key", ENV['HOME'])).and_return(true)
+      expect(IO).to receive(:read).with(File.expand_path("my.key", ENV['HOME']))
       bootstrap_context.validation_key
     end
   end
@@ -85,44 +86,44 @@ EXPECTED
   describe "when an explicit node name is given" do
     let(:config){ {:chef_node_name => 'foobar.example.com' }}
     it "sets the node name in the client.rb" do
-      bootstrap_context.config_content.should match(/node_name "foobar\.example\.com"/)
+      expect(bootstrap_context.config_content).to match(/node_name "foobar\.example\.com"/)
     end
   end
 
   describe "when bootstrapping into a specific environment" do
     let(:chef_config){ {:environment => "prodtastic"} }
     it "starts chef in the configured environment" do
-      bootstrap_context.start_chef.should == 'chef-client -j /etc/chef/first-boot.json -E prodtastic'
+      expect(bootstrap_context.start_chef).to eq('chef-client -j /etc/chef/first-boot.json -E prodtastic')
     end
   end
 
   describe "when JSON attributes are given" do
     let(:config) { {:first_boot_attributes => {:baz => :quux}} }
     it "adds the attributes to first_boot" do
-      Chef::JSONCompat.to_json(bootstrap_context.first_boot).should eq(Chef::JSONCompat.to_json({:baz => :quux, :run_list => run_list}))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({:baz => :quux, :run_list => run_list}))
     end
   end
 
   describe "when JSON attributes are NOT given" do
     it "sets first_boot equal to run_list" do
-      Chef::JSONCompat.to_json(bootstrap_context.first_boot).should eq(Chef::JSONCompat.to_json({:run_list => run_list}))
+      expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({:run_list => run_list}))
     end
   end
 
   describe "when an encrypted_data_bag_secret is provided" do
     let(:secret) { "supersekret" }
     it "reads the encrypted_data_bag_secret" do
-      bootstrap_context.encrypted_data_bag_secret.should eq "supersekret"
+      expect(bootstrap_context.encrypted_data_bag_secret).to eq "supersekret"
     end
   end
 
   describe "to support compatibility with existing templates" do
     it "sets the @config instance variable" do
-      bootstrap_context.instance_variable_get(:@config).should eq config
+      expect(bootstrap_context.instance_variable_get(:@config)).to eq config
     end
 
     it "sets the @run_list instance variable" do
-      bootstrap_context.instance_variable_get(:@run_list).should eq run_list
+      expect(bootstrap_context.instance_variable_get(:@run_list)).to eq run_list
     end
   end
 
@@ -134,7 +135,7 @@ EXPECTED
     end
 
     it "should send the full version to the installer" do
-      bootstrap_context.latest_current_chef_version_string.should eq("-v 11.12.4")
+      expect(bootstrap_context.latest_current_chef_version_string).to eq("-v 11.12.4")
     end
   end
 
@@ -146,20 +147,20 @@ EXPECTED
     end
 
     it "should send the full version to the installer and set the pre-release flag" do
-      bootstrap_context.latest_current_chef_version_string.should eq("-v 11.12.4.rc.0 -p")
+      expect(bootstrap_context.latest_current_chef_version_string).to eq("-v 11.12.4.rc.0 -p")
     end
   end
 
   describe "when a bootstrap_version is not specified" do
     it "should send the latest current to the installer" do
       # Intentionally hard coded in order not to replicate the logic.
-      bootstrap_context.latest_current_chef_version_string.should eq("-v #{Chef::VERSION.to_i}")
+      expect(bootstrap_context.latest_current_chef_version_string).to eq("-v #{Chef::VERSION.to_i}")
     end
   end
 
   describe "ssl_verify_mode" do
     it "isn't set in the config_content by default" do
-      bootstrap_context.config_content.should_not include("ssl_verify_mode")
+      expect(bootstrap_context.config_content).not_to include("ssl_verify_mode")
     end
 
     describe "when configured in config" do
@@ -170,14 +171,14 @@ EXPECTED
       end
 
       it "uses the config value" do
-        bootstrap_context.config_content.should include("ssl_verify_mode :verify_peer")
+        expect(bootstrap_context.config_content).to include("ssl_verify_mode :verify_peer")
       end
 
       describe "when configured via CLI" do
         let(:config) {{:node_ssl_verify_mode => "none"}}
 
         it "uses CLI value" do
-          bootstrap_context.config_content.should include("ssl_verify_mode :verify_none")
+          expect(bootstrap_context.config_content).to include("ssl_verify_mode :verify_none")
         end
       end
     end
@@ -185,7 +186,7 @@ EXPECTED
 
   describe "verify_api_cert" do
     it "isn't set in the config_content by default" do
-      bootstrap_context.config_content.should_not include("verify_api_cert")
+      expect(bootstrap_context.config_content).not_to include("verify_api_cert")
     end
 
     describe "when configured in config" do
@@ -196,17 +197,31 @@ EXPECTED
       end
 
       it "uses the config value" do
-        bootstrap_context.config_content.should include("verify_api_cert false")
+        expect(bootstrap_context.config_content).to include("verify_api_cert false")
       end
 
       describe "when configured via CLI" do
         let(:config) {{:node_verify_api_cert => true}}
 
         it "uses CLI value" do
-          bootstrap_context.config_content.should include("verify_api_cert true")
+          expect(bootstrap_context.config_content).to include("verify_api_cert true")
         end
       end
     end
   end
 
+  describe "prerelease" do
+    it "isn't set in the config_content by default" do
+      expect(bootstrap_context.config_content).not_to include("prerelease")
+    end
+
+    describe "when configured via cli" do
+      let(:config) {{:prerelease => true}}
+
+      it "uses CLI value" do
+        expect(bootstrap_context.latest_current_chef_version_string).to eq("-p")
+      end
+    end
+  end
+
 end

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

@@ -39,45 +39,45 @@ BRANCHES
   end
 
   it "has a path to the cookbook repo" do
-    @cookbook_repo.repo_path.should == @repo_path
+    expect(@cookbook_repo.repo_path).to eq(@repo_path)
   end
 
   it "has a default branch" do
-    @cookbook_repo.default_branch.should == 'master'
+    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
-      ::File.should_receive(:directory?).with(@repo_path).and_return(false)
-      lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit)
+      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
-        ::File.stub(:directory?).with(@repo_path).and_return(true)
+        allow(::File).to receive(:directory?).with(@repo_path).and_return(true)
       end
 
       it "exits when there is no git repo" do
-        ::File.stub(:directory?).with(/.*\.git/).and_return(false)
-        lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit)
+        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
-          ::File.stub(:directory?).with(File.join(@repo_path, '.git')).and_return(true)
+          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"}
-          @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@nobranches)
-          lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit)
+          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"
-            @cookbook_repo.should_receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@master_branch)
+            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
@@ -85,14 +85,14 @@ BRANCHES
             @dirty_status.stdout.replace(<<-DIRTY)
  M chef/lib/chef/knife/cookbook_site_vendor.rb
 DIRTY
-            @cookbook_repo.should_receive(:shell_out!).with('git status --porcelain', :cwd => @repo_path).and_return(@dirty_status)
-            lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit)
+            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")}
-              @cookbook_repo.stub(:shell_out!).with('git status --porcelain', :cwd => @repo_path).and_return(@clean_status)
+              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
@@ -106,35 +106,35 @@ DIRTY
   end
 
   it "resets to default state by checking out the default branch" do
-    @cookbook_repo.should_receive(:shell_out!).with('git checkout master', :cwd => @repo_path)
+    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
-    @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list)
-    @cookbook_repo.branch_exists?("chef-vendor-apache2").should be_true
-    @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list)
-    @cookbook_repo.branch_exists?("chef-vendor-nginx").should be_false
+    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
-    @cookbook_repo.should_receive(:shell_out!).twice.with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list)
-    @cookbook_repo.should_not be_branch_exists("chef-vendor-absent")
-    @cookbook_repo.should be_branch_exists("chef-vendor-absent-new")
+    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
-      @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list)
-      @cookbook_repo.should_receive(:shell_out!).with('git checkout -b chef-vendor-nginx', :cwd => @repo_path)
+      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
-      @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list)
-      @cookbook_repo.should_receive(:shell_out!).with('git checkout chef-vendor-apache2', :cwd => @repo_path)
+      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
@@ -143,15 +143,15 @@ DIRTY
     before do
       @updates = Mixlib::ShellOut.new
       @updates.stdout.replace("\n")
-      @cookbook_repo.stub(:shell_out!).with('git status --porcelain -- apache2', :cwd => @repo_path).and_return(@updates)
+      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
-      @cookbook_repo.updated?('apache2').should be_false
+      expect(@cookbook_repo.updated?('apache2')).to be_falsey
     end
 
     it "does nothing to finalize the updates" do
-      @cookbook_repo.finalize_updates_to('apache2', '1.2.3').should be_false
+      expect(@cookbook_repo.finalize_updates_to('apache2', '1.2.3')).to be_falsey
     end
   end
 
@@ -159,18 +159,18 @@ DIRTY
     before do
       @updates = Mixlib::ShellOut.new
       @updates.stdout.replace(" M cookbooks/apache2/recipes/default.rb\n")
-      @cookbook_repo.stub(:shell_out!).with('git status --porcelain -- apache2', :cwd => @repo_path).and_return(@updates)
+      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
-      @cookbook_repo.updated?('apache2').should be_true
+      expect(@cookbook_repo.updated?('apache2')).to be_truthy
     end
 
     it "commits the changes to the repo and tags the commit" do
-      @cookbook_repo.should_receive(:shell_out!).with("git add apache2", :cwd => @repo_path)
-      @cookbook_repo.should_receive(:shell_out!).with("git commit -m \"Import apache2 version 1.2.3\" -- apache2", :cwd => @repo_path)
-      @cookbook_repo.should_receive(:shell_out!).with("git tag -f cookbook-site-imported-apache2-1.2.3", :cwd => @repo_path)
-      @cookbook_repo.finalize_updates_to("apache2", "1.2.3").should be_true
+      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
 
@@ -180,7 +180,7 @@ DIRTY
     end
 
     it "resets to default state by checking out the default branch" do
-      @cookbook_repo.should_receive(:shell_out!).with('git checkout develop', :cwd => @repo_path)
+      expect(@cookbook_repo).to receive(:shell_out!).with('git checkout develop', :cwd => @repo_path)
       @cookbook_repo.reset_to_default_state
     end
   end

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

@@ -24,17 +24,17 @@ describe Chef::Knife::Core::ObjectLoader do
   before(:each) do
     @knife = Chef::Knife.new
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
     Dir.chdir(File.join(CHEF_SPEC_DATA, 'object_loader'))
   end
 
   shared_examples_for "Chef object" do |chef_class|
     it "should create a #{chef_class} object" do
-      @object.should be_a_kind_of(chef_class)
+      expect(@object).to be_a_kind_of(chef_class)
     end
 
     it "should has a attribute 'name'" do
-      @object.name.should eql('test')
+      expect(@object.name).to eql('test')
     end
   end
 

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

@@ -20,22 +20,22 @@ require 'spec_helper'
 
 describe Chef::Knife::SubcommandLoader do
   before do
-    Chef::Platform.stub(:windows?) { false }
+    allow(Chef::Platform).to receive(:windows?) { false }
     @home = File.join(CHEF_SPEC_DATA, 'knife-home')
     @env = {'HOME' => @home}
     @loader = Chef::Knife::SubcommandLoader.new(File.join(CHEF_SPEC_DATA, 'knife-site-subcommands'), @env)
   end
 
   it "builds a list of the core subcommand file require paths" do
-    @loader.subcommand_files.should_not be_empty
+    expect(@loader.subcommand_files).not_to be_empty
     @loader.subcommand_files.each do |require_path|
-      require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/)
+      expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
     end
   end
 
   it "finds files installed via rubygems" do
-    @loader.find_subcommands_via_rubygems.should include('chef/knife/node_create')
-    @loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| abs_path.should match(%r[chef/knife/.+])}
+    expect(@loader.find_subcommands_via_rubygems).to include('chef/knife/node_create')
+    @loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
   end
 
   it "finds files from latest version of installed gems" do
@@ -44,74 +44,148 @@ describe Chef::Knife::SubcommandLoader do
       '/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'
     ]
-    $LOAD_PATH.should_receive(:map).and_return([])
+    expect($LOAD_PATH).to receive(:map).and_return([])
     if Gem::Specification.respond_to? :latest_specs
-      Gem::Specification.should_receive(:latest_specs).with(true).and_return(gems)
-      gems[0].should_receive(:matches_for_glob).with(/chef\/knife\/\*\.rb\{(.*),\.rb,(.*)\}/).and_return(gem_files)
+      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return(gems)
+      expect(gems[0]).to receive(:matches_for_glob).with(/chef\/knife\/\*\.rb\{(.*),\.rb,(.*)\}/).and_return(gem_files)
     else
-      Gem.source_index.should_receive(:latest_specs).with(true).and_return(gems)
-      gems[0].should_receive(:require_paths).twice.and_return(['lib'])
-      gems[0].should_receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12')
-      Dir.should_receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files)
+      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
-    @loader.should_receive(:find_subcommands_via_dirglob).and_return({})
-    @loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort.should == gem_files
+    expect(@loader).to receive(:find_subcommands_via_dirglob).and_return({})
+    expect(@loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort).to eq(gem_files)
   end
 
   it "finds files using a dirglob when rubygems is not available" do
-    @loader.find_subcommands_via_dirglob.should include('chef/knife/node_create')
-    @loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| abs_path.should match(%r[chef/knife/.+])}
+    expect(@loader.find_subcommands_via_dirglob).to include('chef/knife/node_create')
+    @loader.find_subcommands_via_dirglob.each {|rel_path, 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')
-    @loader.site_subcommands.should include(expected_command)
+    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')
-    @loader.site_subcommands.should include(expected_command)
+    expect(@loader.site_subcommands).to include(expected_command)
   end
 
-  describe "finding 3rd party plugins" do 
+  # https://github.com/opscode/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.
+  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",
+
+        # 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-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
-      ENV.stub(:[]).and_return { |key| env_dup[key] }
-      ENV.stub(:[]).with("HOME").and_return(env_home)
+      allow(ENV).to receive(:[]) { |key| env_dup[key] }
+      allow(ENV).to receive(:[]).with("HOME").and_return(env_home)
     end
 
     context "when there is not a ~/.chef/plugin_manifest.json file" do
       before do
-        File.stub(:exist?).with(manifest_path).and_return(false)
+        allow(File).to receive(:exist?).with(manifest_path).and_return(false)
       end
 
       it "searches rubygems for plugins" do
         if Gem::Specification.respond_to?(:latest_specs)
-          Gem::Specification.should_receive(:latest_specs).and_call_original
+          expect(Gem::Specification).to receive(:latest_specs).and_call_original
         else
-          Gem.source_index.should_receive(:latest_specs).and_call_original
+          expect(Gem.source_index).to receive(:latest_specs).and_call_original
         end
         @loader.subcommand_files.each do |require_path|
-          require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/)
+          expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
         end
       end
 
       context "and HOME environment variable is not set" do
         before do
-          ENV.stub(:[]).with("HOME").and_return(nil)
+          allow(ENV).to receive(:[]).with("HOME").and_return(nil)
         end
 
         it "searches rubygems for plugins" do
           if Gem::Specification.respond_to?(:latest_specs)
-            Gem::Specification.should_receive(:latest_specs).and_call_original
+            expect(Gem::Specification).to receive(:latest_specs).and_call_original
           else
-            Gem.source_index.should_receive(:latest_specs).and_call_original
+            expect(Gem.source_index).to receive(:latest_specs).and_call_original
           end
           @loader.subcommand_files.each do |require_path|
-            require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/)
+            expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
           end
         end
       end
@@ -135,13 +209,13 @@ describe Chef::Knife::SubcommandLoader do
       let(:manifest_json) { Chef::JSONCompat.to_json(manifest_content) }
 
       before do
-        File.stub(:exist?).with(manifest_path).and_return(true)
-        File.stub(:read).with(manifest_path).and_return(manifest_json)
+        allow(File).to receive(:exist?).with(manifest_path).and_return(true)
+        allow(File).to receive(:read).with(manifest_path).and_return(manifest_json)
       end
 
       it "uses paths from the manifest instead of searching gems" do
-        Gem::Specification.should_not_receive(:latest_specs).and_call_original
-        @loader.subcommand_files.should include(ec2_server_create_plugin)
+        expect(Gem::Specification).not_to receive(:latest_specs).and_call_original
+        expect(@loader.subcommand_files).to include(ec2_server_create_plugin)
       end
 
     end