chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/knife/cookbook_site_install_spec.rb

@@ -184,7 +184,11 @@ describe Chef::Knife::CookbookSiteInstall do
     end
 
     it "rasies an error if it finds no metadata file" do
-      expect { knife.preferred_metadata }.to raise_error(Chef::Exceptions::MetadataNotFound)
+      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/cookbook_site_share_spec.rb

@@ -32,27 +32,27 @@ describe Chef::Knife::CookbookSiteShare do
     @cookbook = Chef::CookbookVersion.new('cookbook_name')
 
     @cookbook_loader = double('Chef::CookbookLoader')
-    @cookbook_loader.stub(:cookbook_exists?).and_return(true)
-    @cookbook_loader.stub(:[]).and_return(@cookbook)
-    Chef::CookbookLoader.stub(:new).and_return(@cookbook_loader)
+    allow(@cookbook_loader).to receive(:cookbook_exists?).and_return(true)
+    allow(@cookbook_loader).to receive(:[]).and_return(@cookbook)
+    allow(Chef::CookbookLoader).to receive(:new).and_return(@cookbook_loader)
 
     @noauth_rest = double(Chef::REST)
-    @knife.stub(:noauth_rest).and_return(@noauth_rest)
+    allow(@knife).to receive(:noauth_rest).and_return(@noauth_rest)
 
     @cookbook_uploader = Chef::CookbookUploader.new('herpderp', :rest => "norest")
-    Chef::CookbookUploader.stub(:new).and_return(@cookbook_uploader)
-    @cookbook_uploader.stub(:validate_cookbooks).and_return(true)
-    Chef::CookbookSiteStreamingUploader.stub(:create_build_dir).and_return(Dir.mktmpdir)
+    allow(Chef::CookbookUploader).to receive(:new).and_return(@cookbook_uploader)
+    allow(@cookbook_uploader).to receive(:validate_cookbooks).and_return(true)
+    allow(Chef::CookbookSiteStreamingUploader).to receive(:create_build_dir).and_return(Dir.mktmpdir)
 
-    @knife.stub(:shell_out!).and_return(true)
+    allow(@knife).to receive(:shell_out!).and_return(true)
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   describe 'run' do
 
     before(:each) do
-      @knife.stub(:do_upload).and_return(true)
+      allow(@knife).to receive(:do_upload).and_return(true)
       @category_response = {
         "name" => "cookbook_name",
         "category" => "Testing Category"
@@ -66,72 +66,81 @@ describe Chef::Knife::CookbookSiteShare do
     end
 
     it 'should set true to config[:dry_run] as default' do
-      @knife.config[:dry_run].should be_false
+      expect(@knife.config[:dry_run]).to be_falsey
     end
 
     it 'should should print usage and exit when given no arguments' do
       @knife.name_args = []
-      @knife.should_receive(:show_usage)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it 'should not fail when given only 1 argument and can determine category' do
       @knife.name_args = ['cookbook_name']
-      @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@category_response)
-      @knife.should_receive(:do_upload)
+      expect(@noauth_rest).to receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@category_response)
+      expect(@knife).to receive(:do_upload)
       @knife.run
     end
 
     it 'should print error and exit when given only 1 argument and cannot determine category' do
       @knife.name_args = ['cookbook_name']
-      @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@bad_category_response)
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@noauth_rest).to receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@bad_category_response)
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it 'should print error and exit when given only 1 argument and Chef::REST throws an exception' do
       @knife.name_args = ['cookbook_name']
-      @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name") { raise Errno::ECONNREFUSED, "Connection refused" }
-      @knife.ui.should_receive(:fatal)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect(@noauth_rest).to receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name") { raise Errno::ECONNREFUSED, "Connection refused" }
+      expect(@knife.ui).to receive(:fatal)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it 'should check if the cookbook exists' do
-      @cookbook_loader.should_receive(:cookbook_exists?)
+      expect(@cookbook_loader).to receive(:cookbook_exists?)
       @knife.run
     end
 
     it "should exit and log to error if the cookbook doesn't exist" do
-      @cookbook_loader.stub(:cookbook_exists?).and_return(false)
-      @knife.ui.should_receive(:error)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      allow(@cookbook_loader).to receive(:cookbook_exists?).and_return(false)
+      expect(@knife.ui).to receive(:error)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
-    it 'should make a tarball of the cookbook' do
-      @knife.should_receive(:shell_out!) do |args|
-        args.to_s.should match(/tar -czf/)
+    if File.exists?('/usr/bin/gnutar') || File.exists?('/bin/gnutar')
+      it 'should use gnutar to make a tarball of the cookbook' do
+        expect(@knife).to receive(:shell_out!) do |args|
+          expect(args.to_s).to match(/gnutar -czf/)
+        end
+        @knife.run
+      end
+    else
+      it 'should make a tarball of the cookbook' do
+        expect(@knife).to receive(:shell_out!) do |args|
+          expect(args.to_s).to match(/tar -czf/)
+        end
+        @knife.run
       end
-      @knife.run
     end
 
     it 'should exit and log to error when the tarball creation fails' do
-      @knife.stub(:shell_out!).and_raise(Chef::Exceptions::Exec)
-      @knife.ui.should_receive(:error)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      allow(@knife).to receive(:shell_out!).and_raise(Chef::Exceptions::Exec)
+      expect(@knife.ui).to receive(:error)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it 'should upload the cookbook and clean up the tarball' do
-      @knife.should_receive(:do_upload)
-      FileUtils.should_receive(:rm_rf)
+      expect(@knife).to receive(:do_upload)
+      expect(FileUtils).to receive(:rm_rf)
       @knife.run
     end
 
     context "when the --dry-run flag is specified" do
       before do
-        Chef::CookbookSiteStreamingUploader.stub(:create_build_dir).and_return("/var/tmp/dummy")
+        allow(Chef::CookbookSiteStreamingUploader).to receive(:create_build_dir).and_return("/var/tmp/dummy")
         @knife.config = { :dry_run => true }
-        @knife.stub_chain(:shell_out!, :stdout).and_return('file')
+        allow(@knife).to receive_message_chain(:shell_out!, :stdout).and_return('file')
       end
 
       it "should list files in the tarball" do
@@ -152,46 +161,46 @@ describe Chef::Knife::CookbookSiteShare do
 
     before(:each) do
       @upload_response = double('Net::HTTPResponse')
-      Chef::CookbookSiteStreamingUploader.stub(:post).and_return(@upload_response)
+      allow(Chef::CookbookSiteStreamingUploader).to receive(:post).and_return(@upload_response)
 
       @stdout = StringIO.new
       @stderr = StringIO.new
-      @knife.ui.stub(:stdout).and_return(@stdout)
-      @knife.ui.stub(:stderr).and_return(@stderr)
-      File.stub(:open).and_return(true)
+      allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+      allow(@knife.ui).to receive(:stderr).and_return(@stderr)
+      allow(File).to receive(:open).and_return(true)
     end
 
-    it 'should post the cookbook to "https://supermarket.getchef.com"' do
-      response_text = Chef::JSONCompat.to_json({:uri => 'https://supermarket.getchef.com/cookbooks/cookbook_name'})
-      @upload_response.stub(:body).and_return(response_text)
-      @upload_response.stub(:code).and_return(201)
-      Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/supermarket\.getchef\.com/, anything(), anything(), anything())
+    it 'should post the cookbook to "https://supermarket.chef.io"' do
+      response_text = Chef::JSONCompat.to_json({:uri => 'https://supermarket.chef.io/cookbooks/cookbook_name'})
+      allow(@upload_response).to receive(:body).and_return(response_text)
+      allow(@upload_response).to receive(:code).and_return(201)
+      expect(Chef::CookbookSiteStreamingUploader).to receive(:post).with(/supermarket\.chef\.io/, anything(), anything(), anything())
       @knife.run
     end
 
     it 'should alert the user when a version already exists' do
       response_text = Chef::JSONCompat.to_json({:error_messages => ['Version already exists']})
-      @upload_response.stub(:body).and_return(response_text)
-      @upload_response.stub(:code).and_return(409)
-      lambda { @knife.run }.should raise_error(SystemExit)
-      @stderr.string.should match(/ERROR(.+)cookbook already exists/)
+      allow(@upload_response).to receive(:body).and_return(response_text)
+      allow(@upload_response).to receive(:code).and_return(409)
+      expect { @knife.run }.to raise_error(SystemExit)
+      expect(@stderr.string).to match(/ERROR(.+)cookbook already exists/)
     end
 
     it 'should pass any errors on to the user' do
       response_text = Chef::JSONCompat.to_json({:error_messages => ["You're holding it wrong"]})
-      @upload_response.stub(:body).and_return(response_text)
-      @upload_response.stub(:code).and_return(403)
-      lambda { @knife.run }.should raise_error(SystemExit)
-      @stderr.string.should match("ERROR(.*)You're holding it wrong")
+      allow(@upload_response).to receive(:body).and_return(response_text)
+      allow(@upload_response).to receive(:code).and_return(403)
+      expect { @knife.run }.to raise_error(SystemExit)
+      expect(@stderr.string).to match("ERROR(.*)You're holding it wrong")
     end
 
     it 'should print the body if no errors are exposed on failure' do
       response_text = Chef::JSONCompat.to_json({:system_error => "Your call was dropped", :reason => "There's a map for that"})
-      @upload_response.stub(:body).and_return(response_text)
-      @upload_response.stub(:code).and_return(500)
-      @knife.ui.should_receive(:error).with(/#{Regexp.escape(response_text)}/)#.ordered
-      @knife.ui.should_receive(:error).with(/Unknown error/)#.ordered
-      lambda { @knife.run }.should raise_error(SystemExit)
+      allow(@upload_response).to receive(:body).and_return(response_text)
+      allow(@upload_response).to receive(:code).and_return(500)
+      expect(@knife.ui).to receive(:error).with(/#{Regexp.escape(response_text)}/)#.ordered
+      expect(@knife.ui).to receive(:error).with(/Unknown error/)#.ordered
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
   end

data/spec/unit/knife/cookbook_site_unshare_spec.rb

@@ -24,13 +24,13 @@ describe Chef::Knife::CookbookSiteUnshare do
   before(:each) do
     @knife = Chef::Knife::CookbookSiteUnshare.new
     @knife.name_args = ['cookbook_name']
-    @knife.stub(:confirm).and_return(true)
+    allow(@knife).to receive(:confirm).and_return(true)
 
     @rest = double('Chef::REST')
-    @rest.stub(:delete_rest).and_return(true)
-    @knife.stub(:rest).and_return(@rest)
+    allow(@rest).to receive(:delete_rest).and_return(true)
+    allow(@knife).to receive(:rest).and_return(@rest)
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   describe 'run' do
@@ -38,37 +38,37 @@ describe Chef::Knife::CookbookSiteUnshare do
     describe 'with no cookbook argument' do
       it 'should print the usage and exit' do
         @knife.name_args = []
-        @knife.ui.should_receive(:fatal)
-        @knife.should_receive(:show_usage)
-        lambda { @knife.run }.should raise_error(SystemExit)
+        expect(@knife.ui).to receive(:fatal)
+        expect(@knife).to receive(:show_usage)
+        expect { @knife.run }.to raise_error(SystemExit)
       end
     end
 
     it 'should confirm you want to unshare the cookbook' do
-      @knife.should_receive(:confirm)
+      expect(@knife).to receive(:confirm)
       @knife.run
     end
 
     it 'should send a delete request to the cookbook site' do
-      @rest.should_receive(:delete_rest)
+      expect(@rest).to receive(:delete_rest)
       @knife.run
     end
 
     it 'should log an error and exit when forbidden' do
       exception = double('403 "Forbidden"', :code => '403')
-      @rest.stub(:delete_rest).and_raise(Net::HTTPServerException.new('403 "Forbidden"', exception))
-      @knife.ui.should_receive(:error)
-      lambda { @knife.run }.should raise_error(SystemExit)
+      allow(@rest).to receive(:delete_rest).and_raise(Net::HTTPServerException.new('403 "Forbidden"', exception))
+      expect(@knife.ui).to receive(:error)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it 'should re-raise any non-forbidden errors on delete_rest' do
       exception = double('500 "Application Error"', :code => '500')
-      @rest.stub(:delete_rest).and_raise(Net::HTTPServerException.new('500 "Application Error"', exception))
-      lambda { @knife.run }.should raise_error(Net::HTTPServerException)
+      allow(@rest).to receive(:delete_rest).and_raise(Net::HTTPServerException.new('500 "Application Error"', exception))
+      expect { @knife.run }.to raise_error(Net::HTTPServerException)
     end
 
     it 'should log a success message' do
-      @knife.ui.should_receive(:info)
+      expect(@knife.ui).to receive(:info)
       @knife.run
     end
 

data/spec/unit/knife/cookbook_test_spec.rb

@@ -26,55 +26,55 @@ describe Chef::Knife::CookbookTest do
     Chef::Config[:node_name]  = "webmonkey.example.com"
     @knife = Chef::Knife::CookbookTest.new
     @knife.config[:cookbook_path] = File.join(CHEF_SPEC_DATA,'cookbooks')
-    @knife.cookbook_loader.stub(:cookbook_exists?).and_return(true)
+    allow(@knife.cookbook_loader).to receive(:cookbook_exists?).and_return(true)
     @cookbooks = []
     %w{tats central_market jimmy_johns pho}.each do |cookbook_name|
       @cookbooks << Chef::CookbookVersion.new(cookbook_name)
     end
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
   describe "run" do
     it "should test the cookbook" do
-      @knife.stub(:test_cookbook).and_return(true)
+      allow(@knife).to receive(:test_cookbook).and_return(true)
       @knife.name_args = ["italian"]
-      @knife.should_receive(:test_cookbook).with("italian")
+      expect(@knife).to receive(:test_cookbook).with("italian")
       @knife.run
     end
 
     it "should test multiple cookbooks when provided" do
-      @knife.stub(:test_cookbook).and_return(true)
+      allow(@knife).to receive(:test_cookbook).and_return(true)
       @knife.name_args = ["tats", "jimmy_johns"]
-      @knife.should_receive(:test_cookbook).with("tats")
-      @knife.should_receive(:test_cookbook).with("jimmy_johns")
-      @knife.should_not_receive(:test_cookbook).with("central_market")
-      @knife.should_not_receive(:test_cookbook).with("pho")
+      expect(@knife).to receive(:test_cookbook).with("tats")
+      expect(@knife).to receive(:test_cookbook).with("jimmy_johns")
+      expect(@knife).not_to receive(:test_cookbook).with("central_market")
+      expect(@knife).not_to receive(:test_cookbook).with("pho")
       @knife.run
     end
 
     it "should test both ruby and templates" do
       @knife.name_args = ["example"]
-      @knife.config[:cookbook_path].should_not be_empty
+      expect(@knife.config[:cookbook_path]).not_to be_empty
       Array(@knife.config[:cookbook_path]).reverse.each do |path|
-        @knife.should_receive(:test_ruby).with(an_instance_of(Chef::Cookbook::SyntaxCheck))
-        @knife.should_receive(:test_templates).with(an_instance_of(Chef::Cookbook::SyntaxCheck))
+        expect(@knife).to receive(:test_ruby).with(an_instance_of(Chef::Cookbook::SyntaxCheck))
+        expect(@knife).to receive(:test_templates).with(an_instance_of(Chef::Cookbook::SyntaxCheck))
       end
       @knife.run
     end
 
     describe "with -a or --all" do
       it "should test all of the cookbooks" do
-        @knife.stub(:test_cookbook).and_return(true)
+        allow(@knife).to receive(:test_cookbook).and_return(true)
         @knife.config[:all] = true
         @loader = {}
-        @loader.stub(:load_cookbooks).and_return(@loader)
+        allow(@loader).to receive(:load_cookbooks).and_return(@loader)
         @cookbooks.each do |cookbook|
           @loader[cookbook.name] = cookbook
         end
-        @knife.stub(:cookbook_loader).and_return(@loader)
+        allow(@knife).to receive(:cookbook_loader).and_return(@loader)
         @loader.each do |key, cookbook|
-          @knife.should_receive(:test_cookbook).with(cookbook.name)
+          expect(@knife).to receive(:test_cookbook).with(cookbook.name)
         end
         @knife.run
       end

data/spec/unit/knife/cookbook_upload_spec.rb

@@ -31,8 +31,8 @@ describe Chef::Knife::CookbookUpload do
 
   let(:cookbook_loader) do
     cookbook_loader = cookbooks_by_name.dup
-    cookbook_loader.stub(:merged_cookbooks).and_return([])
-    cookbook_loader.stub(:load_cookbooks).and_return(cookbook_loader)
+    allow(cookbook_loader).to receive(:merged_cookbooks).and_return([])
+    allow(cookbook_loader).to receive(:load_cookbooks).and_return(cookbook_loader)
     cookbook_loader
   end
 
@@ -45,23 +45,23 @@ describe Chef::Knife::CookbookUpload do
   let(:knife) do
     k = Chef::Knife::CookbookUpload.new
     k.name_args = name_args
-    k.ui.stub(:stdout).and_return(output)
-    k.ui.stub(:stderr).and_return(output)
+    allow(k.ui).to receive(:stdout).and_return(output)
+    allow(k.ui).to receive(:stderr).and_return(output)
     k
   end
 
   before(:each) do
-    Chef::CookbookLoader.stub(:new).and_return(cookbook_loader)
+    allow(Chef::CookbookLoader).to receive(:new).and_return(cookbook_loader)
   end
 
   describe 'with --concurrency' do
     it 'should upload cookbooks with predefined concurrency' do
-      Chef::CookbookVersion.stub(:list_all_versions).and_return({})
+      allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({})
       knife.config[:concurrency] = 3
       test_cookbook = Chef::CookbookVersion.new('test_cookbook', '/tmp/blah')
-      cookbook_loader.stub(:each).and_yield("test_cookbook", test_cookbook)
-      cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook"])
-      Chef::CookbookUploader.should_receive(:new).
+      allow(cookbook_loader).to receive(:each).and_yield("test_cookbook", test_cookbook)
+      allow(cookbook_loader).to receive(:cookbook_names).and_return(["test_cookbook"])
+      expect(Chef::CookbookUploader).to receive(:new).
         with( kind_of(Array), { :force => nil, :concurrency => 3}).
         and_return(double("Chef::CookbookUploader", :upload_cookbooks=> true))
       knife.run
@@ -70,26 +70,26 @@ describe Chef::Knife::CookbookUpload do
 
   describe 'run' do
     before(:each) do
-      Chef::CookbookUploader.stub(:new => cookbook_uploader)
-      Chef::CookbookVersion.stub(:list_all_versions).and_return({})
+      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
       knife.name_args = []
-      knife.should_receive(:show_usage)
-      knife.ui.should_receive(:fatal)
-      lambda { knife.run }.should raise_error(SystemExit)
+      expect(knife).to receive(:show_usage)
+      expect(knife.ui).to receive(:fatal)
+      expect { knife.run }.to raise_error(SystemExit)
     end
 
     describe 'when specifying a cookbook name' do
       it 'should upload the cookbook' do
-        knife.should_receive(:upload).once
+        expect(knife).to receive(:upload).once
         knife.run
       end
 
       it 'should report on success' do
-        knife.should_receive(:upload).once
-        knife.ui.should_receive(:info).with(/Uploaded 1 cookbook/)
+        expect(knife).to receive(:upload).once
+        expect(knife.ui).to receive(:info).with(/Uploaded 1 cookbook/)
         knife.run
       end
     end
@@ -97,7 +97,7 @@ describe Chef::Knife::CookbookUpload do
     describe 'when specifying the same cookbook name twice' do
       it 'should upload the cookbook only once' do
         knife.name_args = ['test_cookbook', 'test_cookbook']
-        knife.should_receive(:upload).once
+        expect(knife).to receive(:upload).once
         knife.run
       end
     end
@@ -105,8 +105,8 @@ describe Chef::Knife::CookbookUpload do
     context "when uploading a cookbook that uses deprecated overlays" do
 
       before do
-        cookbook_loader.stub(:merged_cookbooks).and_return(['test_cookbook'])
-        cookbook_loader.stub(:merged_cookbook_paths).
+        allow(cookbook_loader).to receive(:merged_cookbooks).and_return(['test_cookbook'])
+        allow(cookbook_loader).to receive(:merged_cookbook_paths).
           and_return({'test_cookbook' => %w{/path/one/test_cookbook /path/two/test_cookbook}})
       end
 
@@ -123,7 +123,7 @@ test_cookbook:
   /path/one/test_cookbook
   /path/two/test_cookbook
 E
-        output.string.should include(expected_message)
+        expect(output.string).to include(expected_message)
       end
     end
 
@@ -139,17 +139,17 @@ E
       end
 
       it "should read only one cookbook" do
-        cookbook_loader.should_receive(:[]).once.with('test_cookbook1').and_call_original
+        expect(cookbook_loader).to receive(:[]).once.with('test_cookbook1').and_call_original
         knife.run
       end
 
       it "should not read all cookbooks" do
-        cookbook_loader.should_not_receive(:load_cookbooks)
+        expect(cookbook_loader).not_to receive(:load_cookbooks)
         knife.run
       end
 
       it "should upload only one cookbook" do
-        knife.should_receive(:upload).exactly(1).times
+        expect(knife).to receive(:upload).exactly(1).times
         knife.run
       end
     end
@@ -181,13 +181,13 @@ E
 
       it "should upload all dependencies once" do
         knife.config[:depends] = true
-        knife.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2", "test_cookbook3"])
-        knife.should_receive(:upload).exactly(3).times
-        lambda do
+        allow(knife).to receive(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2", "test_cookbook3"])
+        expect(knife).to receive(:upload).exactly(3).times
+        expect do
           Timeout::timeout(5) do
             knife.run
           end
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
@@ -196,99 +196,133 @@ E
 
       before(:each) do
         cookbook.metadata.depends("dependency")
-        cookbook_loader.stub(:[])  do |ckbk|
+        allow(cookbook_loader).to receive(:[])  do |ckbk|
           { "test_cookbook" =>  cookbook,
             "dependency" => cookbook_dependency}[ckbk]
         end
-        knife.stub(:cookbook_names).and_return(["cookbook_dependency", "test_cookbook"])
+        allow(knife).to receive(:cookbook_names).and_return(["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
-        cookbook_loader.should_receive(:[]).once.with('test_cookbook')
-        cookbook_loader.should_not_receive(:load_cookbooks)
-        cookbook_uploader.should_not_receive(:upload_cookbooks)
+        expect(cookbook_loader).to receive(:[]).once.with('test_cookbook')
+        expect(cookbook_loader).not_to receive(:load_cookbooks)
+        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)
-        @stderr.string.should include('Cookbook test_cookbook depends on cookbooks which are not currently')
-        @stderr.string.should include('being uploaded and cannot be found on the server.')
-        @stderr.string.should include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'")
+        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")
-        cookbook_loader.stub(:[])  do |ckbk|
+        allow(cookbook_loader).to receive(:[])  do |ckbk|
           { "test_cookbook" =>  cookbook,
             "dependency" => cookbook_dependency,
             "dependency2" => cookbook_dependency2}[ckbk]
         end
-        knife.stub(:cookbook_names).and_return(["dependency", "dependency2", "test_cookbook"])
+        allow(knife).to receive(:cookbook_names).and_return(["dependency", "dependency2", "test_cookbook"])
         expect {knife.run}.to raise_error(SystemExit)
-        @stderr.string.should include('Cookbook test_cookbook depends on cookbooks which are not currently')
-        @stderr.string.should include('being uploaded and cannot be found on the server.')
-        @stderr.string.should include("The missing cookbook(s) are:")
-        @stderr.string.should include("'dependency' version '>= 0.0.0'")
-        @stderr.string.should include("'dependency2' version '>= 0.0.0'")
+        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
 
     it "should freeze the version of the cookbooks if --freeze is specified" do
       knife.config[:freeze] = true
-      cookbook.should_receive(:freeze_version).once
+      expect(cookbook).to receive(:freeze_version).once
       knife.run
     end
 
     describe 'with -a or --all' do
       before(:each) do
         knife.config[:all] = true
-        @test_cookbook1 = Chef::CookbookVersion.new('test_cookbook1', '/tmp/blah')
-        @test_cookbook2 = Chef::CookbookVersion.new('test_cookbook2', '/tmp/blah')
-        cookbook_loader.stub(:each).and_yield("test_cookbook1", @test_cookbook1).and_yield("test_cookbook2", @test_cookbook2)
-        cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2"])
       end
 
-      it 'should upload all cookbooks' do
-        knife.should_receive(:upload).once
-        knife.run
-      end
+      context 'when cookbooks exist in the cookbook path' do
+        before(:each) do
+          @test_cookbook1 = Chef::CookbookVersion.new('test_cookbook1', '/tmp/blah')
+          @test_cookbook2 = Chef::CookbookVersion.new('test_cookbook2', '/tmp/blah')
+          allow(cookbook_loader).to receive(:each).and_yield("test_cookbook1", @test_cookbook1).and_yield("test_cookbook2", @test_cookbook2)
+          allow(cookbook_loader).to receive(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2"])
+        end
 
-      it 'should report on success' do
-        knife.should_receive(:upload).once
-        knife.ui.should_receive(:info).with(/Uploaded all cookbooks/)
-        knife.run
+        it 'should upload all cookbooks' do
+          expect(knife).to receive(:upload).once
+          knife.run
+        end
+
+        it 'should report on success' do
+          expect(knife).to receive(:upload).once
+          expect(knife.ui).to receive(:info).with(/Uploaded all cookbooks/)
+          knife.run
+        end
+
+        it 'should update the version constraints for an environment' do
+          allow(knife).to receive(:assert_environment_valid!).and_return(true)
+          knife.config[:environment] = "production"
+          expect(knife).to receive(:update_version_constraints).once
+          knife.run
+        end
       end
 
-      it 'should update the version constraints for an environment' do
-        knife.stub(:assert_environment_valid!).and_return(true)
-        knife.config[:environment] = "production"
-        knife.should_receive(:update_version_constraints).once
-        knife.run
+      context 'when no cookbooks exist in the cookbook path' do
+        before(:each) do
+          allow(cookbook_loader).to receive(:each)
+        end
+
+        it 'should not upload any cookbooks' do
+          expect(knife).to_not receive(:upload)
+          knife.run
+        end
+
+        context 'when cookbook path is an array' do
+          it 'should warn users that no cookbooks exist' do
+            knife.config[:cookbook_path] = ['/chef-repo/cookbooks', '/home/user/cookbooks']
+            expect(knife.ui).to receive(:warn).with(
+              /Could not find any cookbooks in your cookbook path: #{knife.config[:cookbook_path].join(', ')}\. Use --cookbook-path to specify the desired path\./)
+            knife.run
+          end
+        end
+
+        context 'when cookbook path is a string' do
+          it 'should warn users that no cookbooks exist' do
+            knife.config[:cookbook_path] = '/chef-repo/cookbooks'
+            expect(knife.ui).to receive(:warn).with(
+              /Could not find any cookbooks in your cookbook path: #{knife.config[:cookbook_path]}\. Use --cookbook-path to specify the desired path\./)
+            knife.run
+          end
+        end
       end
     end
 
     describe 'when a frozen cookbook exists on the server' do
       it 'should fail to replace it' do
         exception = Chef::Exceptions::CookbookFrozen.new
-        cookbook_uploader.should_receive(:upload_cookbooks).
+        expect(cookbook_uploader).to receive(:upload_cookbooks).
           and_raise(exception)
-        knife.ui.stub(:error)
-        knife.ui.should_receive(:error).with(exception)
-        lambda { knife.run }.should raise_error(SystemExit)
+        allow(knife.ui).to receive(:error)
+        expect(knife.ui).to receive(:error).with(exception)
+        expect { knife.run }.to raise_error(SystemExit)
       end
 
       it 'should not update the version constraints for an environment' do
-        knife.stub(:assert_environment_valid!).and_return(true)
+        allow(knife).to receive(:assert_environment_valid!).and_return(true)
         knife.config[:environment] = "production"
-        knife.stub(:upload).and_raise(Chef::Exceptions::CookbookFrozen)
-        knife.ui.should_receive(:error).with(/Failed to upload 1 cookbook/)
-        knife.ui.should_receive(:warn).with(/Not updating version constraints/)
-        knife.should_not_receive(:update_version_constraints)
-        lambda { knife.run }.should raise_error(SystemExit)
+        allow(knife).to receive(:upload).and_raise(Chef::Exceptions::CookbookFrozen)
+        expect(knife.ui).to receive(:error).with(/Failed to upload 1 cookbook/)
+        expect(knife.ui).to receive(:warn).with(/Not updating version constraints/)
+        expect(knife).not_to receive(:update_version_constraints)
+        expect { knife.run }.to raise_error(SystemExit)
       end
     end
   end # run