chef 12.0.1 → 12.0.3

data/spec/support/platform_helpers.rb

@@ -1,7 +1,10 @@
 require 'fcntl'
 require 'chef/mixin/shell_out'
 
-include Chef::Mixin::ShellOut
+
+class ShellHelpers
+  extend Chef::Mixin::ShellOut
+end
 
 def ruby_gte_20?
   RUBY_VERSION.to_f >= 2.0
@@ -78,7 +81,7 @@ end
 
 def mac_osx_106?
   if File.exists? "/usr/bin/sw_vers"
-    result = shell_out("/usr/bin/sw_vers")
+    result = ShellHelpers.shell_out("/usr/bin/sw_vers")
     result.stdout.each_line do |line|
       if line =~ /^ProductVersion:\s10.6.*$/
         return true

data/spec/unit/knife/cookbook_site_install_spec.rb

@@ -19,132 +19,173 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 
 describe Chef::Knife::CookbookSiteInstall do
+  let(:knife) { Chef::Knife::CookbookSiteInstall.new }
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:downloader) { Hash.new }
+  let(:repo) { double(:sanity_check => true, :reset_to_default_state => true,
+                      :prepare_to_import => true, :finalize_updates_to => true,
+                      :merge_updates_from => true) }
+  let(:install_path) { if Chef::Platform.windows?
+                        'C:/tmp/chef'
+                      else
+                        '/var/tmp/chef'
+                      end }
+
   before(:each) do
     require 'chef/knife/core/cookbook_scm_repo'
-    @stdout = StringIO.new
-    @knife = Chef::Knife::CookbookSiteInstall.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
-    @knife.config = {}
-    if Chef::Platform.windows?
-      @install_path = 'C:/tmp/chef'
-    else
-      @install_path = '/var/tmp/chef'
-    end
-    @knife.config[:cookbook_path] = [ @install_path ]
-
-    @stdout = StringIO.new
-    @stderr = StringIO.new
-    @knife.stub(:stderr).and_return(@stdout)
-    @knife.stub(:stdout).and_return(@stdout)
-
-    #Assume all external commands would have succeed. :(
-    File.stub(:unlink)
-    File.stub(:rmtree)
-    @knife.stub(:shell_out!).and_return(true)
-
-    #CookbookSiteDownload Stup
-    @downloader = {}
-    @knife.stub(:download_cookbook_to).and_return(@downloader)
-    @downloader.stub(:version).and_return do
-      if @knife.name_args.size == 2
-        @knife.name_args[1]
+
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
+    knife.config = {}
+    knife.config[:cookbook_path] = [ install_path ]
+
+    allow(knife).to receive(:stderr).and_return(stderr)
+    allow(knife).to receive(:stdout).and_return(stdout)
+
+    # Assume all external commands would have succeed. :(
+    allow(File).to receive(:unlink)
+    allow(File).to receive(:rmtree)
+    allow(knife).to receive(:shell_out!).and_return(true)
+
+    # CookbookSiteDownload Stup
+    allow(knife).to receive(:download_cookbook_to).and_return(downloader)
+    allow(downloader).to receive(:version) do
+      if knife.name_args.size == 2
+        knife.name_args[1]
       else
         "0.3.0"
       end
     end
 
-    #Stubs for CookbookSCMRepo
-    @repo = double(:sanity_check => true, :reset_to_default_state => true,
-                 :prepare_to_import => true, :finalize_updates_to => true,
-                 :merge_updates_from => true)
-    Chef::Knife::CookbookSCMRepo.stub(:new).and_return(@repo)
+    # Stubs for CookbookSCMRepo
+    allow(Chef::Knife::CookbookSCMRepo).to receive(:new).and_return(repo)
   end
 
-
   describe "run" do
-    it "should return an error if a cookbook name is not provided" do
-      @knife.name_args = []
-      @knife.ui.should_receive(:error).with("Please specify a cookbook to download and install.")
-      lambda { @knife.run }.should raise_error(SystemExit)
-    end
-
-    it "should return an error if more than two arguments are given" do
-      @knife.name_args = ["foo", "bar", "baz"]
-      @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.")
-      lambda { @knife.run }.should raise_error(SystemExit)
-    end
-
-    it "should return an error if the second argument is not a version" do
-      @knife.name_args = ["getting-started", "1pass"]
-      @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.")
-      lambda { @knife.run }.should raise_error(SystemExit)
-    end
-
-    it "should return an error if the second argument is a four-digit version" do
-      @knife.name_args = ["getting-started", "0.0.0.1"]
-      @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.")
-      lambda { @knife.run }.should raise_error(SystemExit)
-    end
-
-    it "should return an error if the second argument is a one-digit version" do
-      @knife.name_args = ["getting-started", "1"]
-      @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.")
-      lambda { @knife.run }.should raise_error(SystemExit)
-    end
-
-    it "should install the specified version if second argument is a three-digit version" do
-      @knife.name_args = ["getting-started", "0.1.0"]
-      @knife.config[:no_deps] = true
-      upstream_file = File.join(@install_path, "getting-started.tar.gz")
-      @knife.should_receive(:download_cookbook_to).with(upstream_file)
-      @knife.should_receive(:extract_cookbook).with(upstream_file, "0.1.0")
-      @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started"))
-      @repo.should_receive(:merge_updates_from).with("getting-started", "0.1.0")
-      @knife.run
-    end
-
-    it "should install the specified version if second argument is a two-digit version" do
-      @knife.name_args = ["getting-started", "0.1"]
-      @knife.config[:no_deps] = true
-      upstream_file = File.join(@install_path, "getting-started.tar.gz")
-      @knife.should_receive(:download_cookbook_to).with(upstream_file)
-      @knife.should_receive(:extract_cookbook).with(upstream_file, "0.1")
-      @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started"))
-      @repo.should_receive(:merge_updates_from).with("getting-started", "0.1")
-      @knife.run
-    end
-
-    it "should install the latest version if only a cookbook name is given" do
-      @knife.name_args = ["getting-started"]
-      @knife.config[:no_deps] = true
-      upstream_file = File.join(@install_path, "getting-started.tar.gz")
-      @knife.should_receive(:download_cookbook_to).with(upstream_file)
-      @knife.should_receive(:extract_cookbook).with(upstream_file, "0.3.0")
-      @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started"))
-      @repo.should_receive(:merge_updates_from).with("getting-started", "0.3.0")
-      @knife.run
-    end
-
-    it "should not create/reset git branches if use_current_branch is set" do
-      @knife.name_args = ["getting-started"]
-      @knife.config[:use_current_branch] = true
-      @knife.config[:no_deps] = true
-      upstream_file = File.join(@install_path, "getting-started.tar.gz")
-      @repo.should_not_receive(:prepare_to_import)
-      @repo.should_not_receive(:reset_to_default_state)
-      @knife.run
-    end
-
-    it "should not raise an error if cookbook_path is a string" do
-      @knife.config[:cookbook_path] = @install_path
-      @knife.config[:no_deps] = true
-      @knife.name_args = ["getting-started"]
-      upstream_file = File.join(@install_path, "getting-started.tar.gz")
-      @knife.should_receive(:download_cookbook_to).with(upstream_file)
-      @knife.should_receive(:extract_cookbook).with(upstream_file, "0.3.0")
-      @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started"))
-      @repo.should_receive(:merge_updates_from).with("getting-started", "0.3.0")
-      lambda { @knife.run }.should_not raise_error
+    it "raises an error if a cookbook name is not provided" do
+      knife.name_args = []
+      expect(knife.ui).to receive(:error).with("Please specify a cookbook to download and install.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if more than two arguments are given" do
+      knife.name_args = ["foo", "bar", "baz"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if the second argument is not a version" do
+      knife.name_args = ["getting-started", "1pass"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if the second argument is a four-digit version" do
+      knife.name_args = ["getting-started", "0.0.0.1"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if the second argument is a one-digit version" do
+      knife.name_args = ["getting-started", "1"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "installs the specified version if second argument is a three-digit version" do
+      knife.name_args = ["getting-started", "0.1.0"]
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.1.0")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.1.0")
+      knife.run
+    end
+
+    it "installs the specified version if second argument is a two-digit version" do
+      knife.name_args = ["getting-started", "0.1"]
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.1")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.1")
+      knife.run
+    end
+
+    it "installs the latest version if only a cookbook name is given" do
+      knife.name_args = ["getting-started"]
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.3.0")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.3.0")
+      knife.run
+    end
+
+    it "does not create/reset git branches if use_current_branch is set" do
+      knife.name_args = ["getting-started"]
+      knife.config[:use_current_branch] = true
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(repo).not_to receive(:prepare_to_import)
+      expect(repo).not_to receive(:reset_to_default_state)
+      knife.run
     end
+
+    it "does not raise an error if cookbook_path is a string" do
+      knife.config[:cookbook_path] = install_path
+      knife.config[:no_deps] = true
+      knife.name_args = ["getting-started"]
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.3.0")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.3.0")
+      expect { knife.run }.not_to raise_error
+    end
+  end # end of run
+
+  let(:metadata) { Chef::Cookbook::Metadata.new }
+  let(:rb_metadata_path) { File.join(install_path, "post-punk-kitchen", "metadata.rb") }
+  let(:json_metadata_path) { File.join(install_path, "post-punk-kitchen", "metadata.json") }
+
+  describe "preferred_metadata" do
+    before do
+      allow(Chef::Cookbook::Metadata).to receive(:new).and_return(metadata)
+      allow(File).to receive(:exist?).and_return(false)
+      knife.instance_variable_set(:@cookbook_name, "post-punk-kitchen")
+      knife.instance_variable_set(:@install_path, install_path)
+    end
+
+    it "returns a populated Metadata object if metadata.rb exists" do
+      allow(File).to receive(:exist?).with(rb_metadata_path).and_return(true)
+      expect(metadata).to receive(:from_file).with(rb_metadata_path)
+      knife.preferred_metadata
+    end
+
+    it "returns a populated Metadata object if metadata.json exists" do
+      allow(File).to receive(:exist?).with(json_metadata_path).and_return(true)
+      #expect(IO).to receive(:read).with(json_metadata_path)
+      allow(IO).to receive(:read)
+      expect(metadata).to receive(:from_json)
+      knife.preferred_metadata
+    end
+
+    it "prefers metadata.rb over metadata.json" do
+      allow(File).to receive(:exist?).with(rb_metadata_path).and_return(true)
+      allow(File).to receive(:exist?).with(json_metadata_path).and_return(true)
+      allow(IO).to receive(:read)
+      expect(metadata).to receive(:from_file).with(rb_metadata_path)
+      expect(metadata).not_to receive(:from_json)
+      knife.preferred_metadata
+    end
+
+    it "rasies an error if it finds no metadata file" do
+      expect { knife.preferred_metadata }.to raise_error(Chef::Exceptions::MetadataNotFound)
+    end
+
   end
 end

data/spec/unit/knife_spec.rb

@@ -25,23 +25,26 @@ require 'spec_helper'
 require 'uri'
 
 describe Chef::Knife do
+
+  let(:stderr) { StringIO.new }
+
+  let(:knife) { Chef::Knife.new }
+
   before(:each) do
     Chef::Log.logger = Logger.new(StringIO.new)
 
     Chef::Config[:node_name]  = "webmonkey.example.com"
 
     # Prevent gratuitous code reloading:
-    Chef::Knife.stub(:load_commands)
-    @knife = Chef::Knife.new
-    @knife.ui.stub(:puts)
-    @knife.ui.stub(:print)
-    Chef::Log.stub(:init)
-    Chef::Log.stub(:level)
+    allow(Chef::Knife).to receive(:load_commands)
+    allow(knife.ui).to receive(:puts)
+    allow(knife.ui).to receive(:print)
+    allow(Chef::Log).to receive(:init)
+    allow(Chef::Log).to receive(:level)
     [:debug, :info, :warn, :error, :crit].each do |level_sym|
       Chef::Log.stub(level_sym)
     end
-    Chef::Knife.stub(:puts)
-    @stderr = StringIO.new
+    allow(Chef::Knife).to receive(:puts)
   end
 
   after(:each) do
@@ -217,9 +220,12 @@ describe Chef::Knife do
     end
 
     it "exits if no subcommand matches the CLI args" do
-      Chef::Knife.ui.stub(:stderr).and_return(@stderr)
-      Chef::Knife.ui.should_receive(:fatal)
-      lambda {Chef::Knife.run(%w{fuuu uuuu fuuuu})}.should raise_error(SystemExit) { |e| e.status.should_not == 0 }
+      stdout = StringIO.new
+
+      allow(Chef::Knife.ui).to receive(:stderr).and_return(stderr)
+      allow(Chef::Knife.ui).to receive(:stdout).and_return(stdout)
+      expect(Chef::Knife.ui).to receive(:fatal)
+      expect {Chef::Knife.run(%w{fuuu uuuu fuuuu})}.to raise_error(SystemExit) { |e| expect(e.status).not_to eq(0) }
     end
 
     it "loads lazy dependencies" do
@@ -269,157 +275,181 @@ describe Chef::Knife do
         let(:fake_config) { "/does/not/exist/knife.rb" }
 
         before do
-          @knife.config[:verbosity] = 1
-          @knife.config[:config_file] = fake_config
+          knife.config[:verbosity] = 1
+          knife.config[:config_file] = fake_config
           config_loader = double("Chef::WorkstationConfigLoader", :load => true, :no_config_found? => false, :chef_config_dir => "/etc/chef", :config_location => fake_config)
           allow(config_loader).to receive(:explicit_config_file=).with(fake_config).and_return(fake_config)
           allow(Chef::WorkstationConfigLoader).to receive(:new).and_return(config_loader)
         end
 
         it "prints the path to the configuration file used" do
-          @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
-          @knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
+          stdout, stderr, stdin = StringIO.new, StringIO.new, StringIO.new
+          knife.ui = Chef::Knife::UI.new(stdout, stderr, stdin, {})
           expect(Chef::Log).to receive(:info).with("Using configuration from #{fake_config}")
-          @knife.configure_chef
+          knife.configure_chef
         end
       end
     end
   end
 
   describe "when first created" do
+
+    let(:knife) { KnifeSpecs::TestYourself.new(%w{with some args -s scrogramming}) }
+
     before do
       unless KnifeSpecs.const_defined?(:TestYourself)
         Kernel.load(File.join(CHEF_SPEC_DATA, 'knife_subcommand', 'test_yourself.rb'))
       end
-      @knife = KnifeSpecs::TestYourself.new(%w{with some args -s scrogramming})
     end
 
     it "it parses the options passed to it" do
-      @knife.config[:scro].should == 'scrogramming'
+      expect(knife.config[:scro]).to eq('scrogramming')
     end
 
     it "extracts its command specific args from the full arg list" do
-      @knife.name_args.should == %w{with some args}
+      expect(knife.name_args).to eq(%w{with some args})
     end
 
     it "does not have lazy dependencies loaded" do
-      @knife.class.test_deps_loaded.should_not be_true
+      expect(knife.class.test_deps_loaded).to be(nil)
     end
   end
 
   describe "when formatting exceptions" do
+
+    let(:stdout) { StringIO.new }
+    let(:stderr) { StringIO.new }
+    let(:stdin) { StringIO.new }
+
+    let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
+
     before do
-      @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new
-      @knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {})
-      @knife.should_receive(:exit).with(100)
+      knife.ui = ui
+      expect(knife).to receive(:exit).with(100)
     end
 
     it "formats 401s nicely" do
       response = Net::HTTPUnauthorized.new("1.1", "401", "Unauthorized")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no syncronize your clock?"))
-      @knife.stub(:run).and_raise(Net::HTTPServerException.new("401 Unauthorized", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(/ERROR: Failed to authenticate to/)
-      @stderr.string.should match(/Response:  y u no syncronize your clock\?/)
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no syncronize your clock?"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("401 Unauthorized", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(/ERROR: Failed to authenticate to/)
+      expect(stderr.string).to match(/Response:  y u no syncronize your clock\?/)
     end
 
     it "formats 403s nicely" do
       response = Net::HTTPForbidden.new("1.1", "403", "Forbidden")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no administrator"))
-      @knife.stub(:run).and_raise(Net::HTTPServerException.new("403 Forbidden", response))
-      @knife.stub(:username).and_return("sadpanda")
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action])
-      @stderr.string.should match(%r[Response:  y u no administrator])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u no administrator"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("403 Forbidden", response))
+      allow(knife).to receive(:username).and_return("sadpanda")
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action])
+      expect(stderr.string).to match(%r[Response:  y u no administrator])
     end
 
     it "formats 400s nicely" do
       response = Net::HTTPBadRequest.new("1.1", "400", "Bad Request")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "y u search wrong"))
-      @knife.stub(:run).and_raise(Net::HTTPServerException.new("400 Bad Request", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: The data in your request was invalid])
-      @stderr.string.should match(%r[Response: y u search wrong])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "y u search wrong"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("400 Bad Request", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: The data in your request was invalid])
+      expect(stderr.string).to match(%r[Response: y u search wrong])
     end
 
     it "formats 404s nicely" do
       response = Net::HTTPNotFound.new("1.1", "404", "Not Found")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "nothing to see here"))
-      @knife.stub(:run).and_raise(Net::HTTPServerException.new("404 Not Found", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: The object you are looking for could not be found])
-      @stderr.string.should match(%r[Response: nothing to see here])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "nothing to see here"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("404 Not Found", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: The object you are looking for could not be found])
+      expect(stderr.string).to match(%r[Response: nothing to see here])
     end
 
     it "formats 500s nicely" do
       response = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone"))
-      @knife.stub(:run).and_raise(Net::HTTPFatalError.new("500 Internal Server Error", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: internal server error])
-      @stderr.string.should match(%r[Response: sad trombone])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sad trombone"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("500 Internal Server Error", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: internal server error])
+      expect(stderr.string).to match(%r[Response: sad trombone])
     end
 
     it "formats 502s nicely" do
       response = Net::HTTPBadGateway.new("1.1", "502", "Bad Gateway")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "sadder trombone"))
-      @knife.stub(:run).and_raise(Net::HTTPFatalError.new("502 Bad Gateway", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: bad gateway])
-      @stderr.string.should match(%r[Response: sadder trombone])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "sadder trombone"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("502 Bad Gateway", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: bad gateway])
+      expect(stderr.string).to match(%r[Response: sadder trombone])
     end
 
     it "formats 503s nicely" do
       response = Net::HTTPServiceUnavailable.new("1.1", "503", "Service Unavailable")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "saddest trombone"))
-      @knife.stub(:run).and_raise(Net::HTTPFatalError.new("503 Service Unavailable", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: Service temporarily unavailable])
-      @stderr.string.should match(%r[Response: saddest trombone])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "saddest trombone"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("503 Service Unavailable", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: Service temporarily unavailable])
+      expect(stderr.string).to match(%r[Response: saddest trombone])
     end
 
     it "formats other HTTP errors nicely" do
       response = Net::HTTPPaymentRequired.new("1.1", "402", "Payment Required")
       response.instance_variable_set(:@read, true) # I hate you, net/http.
-      response.stub(:body).and_return(Chef::JSONCompat.to_json(:error => "nobugfixtillyoubuy"))
-      @knife.stub(:run).and_raise(Net::HTTPServerException.new("402 Payment Required", response))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: Payment Required])
-      @stderr.string.should match(%r[Response: nobugfixtillyoubuy])
+      allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(:error => "nobugfixtillyoubuy"))
+      allow(knife).to receive(:run).and_raise(Net::HTTPServerException.new("402 Payment Required", response))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: Payment Required])
+      expect(stderr.string).to match(%r[Response: nobugfixtillyoubuy])
     end
 
     it "formats NameError and NoMethodError nicely" do
-      @knife.stub(:run).and_raise(NameError.new("Undefined constant FUUU"))
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: knife encountered an unexpected error])
-      @stderr.string.should match(%r[This may be a bug in the 'knife' knife command or plugin])
-      @stderr.string.should match(%r[Exception: NameError: Undefined constant FUUU])
+      allow(knife).to receive(:run).and_raise(NameError.new("Undefined constant FUUU"))
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: knife encountered an unexpected error])
+      expect(stderr.string).to match(%r[This may be a bug in the 'knife' knife command or plugin])
+      expect(stderr.string).to match(%r[Exception: NameError: Undefined constant FUUU])
     end
 
     it "formats missing private key errors nicely" do
-      @knife.stub(:run).and_raise(Chef::Exceptions::PrivateKeyMissing.new('key not there'))
-      @knife.stub(:api_key).and_return("/home/root/.chef/no-key-here.pem")
-      @knife.run_with_pretty_exceptions
-      @stderr.string.should match(%r[ERROR: Your private key could not be loaded from /home/root/.chef/no-key-here.pem])
-      @stderr.string.should match(%r[Check your configuration file and ensure that your private key is readable])
+      allow(knife).to receive(:run).and_raise(Chef::Exceptions::PrivateKeyMissing.new('key not there'))
+      allow(knife).to receive(:api_key).and_return("/home/root/.chef/no-key-here.pem")
+      knife.run_with_pretty_exceptions
+      expect(stderr.string).to match(%r[ERROR: Your private key could not be loaded from /home/root/.chef/no-key-here.pem])
+      expect(stderr.string).to match(%r[Check your configuration file and ensure that your private key is readable])
     end
 
     it "formats connection refused errors nicely" do
-      @knife.stub(:run).and_raise(Errno::ECONNREFUSED.new('y u no shut up'))
-      @knife.run_with_pretty_exceptions
+      allow(knife).to receive(:run).and_raise(Errno::ECONNREFUSED.new('y u no shut up'))
+      knife.run_with_pretty_exceptions
       # Errno::ECONNREFUSED message differs by platform
       # *nix = Errno::ECONNREFUSED: Connection refused
       # win32: Errno::ECONNREFUSED: No connection could be made because the target machine actively refused it.
-      @stderr.string.should match(%r[ERROR: Network Error: .* - y u no shut up])
-      @stderr.string.should match(%r[Check your knife configuration and network settings])
+      expect(stderr.string).to match(%r[ERROR: Network Error: .* - y u no shut up])
+      expect(stderr.string).to match(%r[Check your knife configuration and network settings])
     end
+
+    it "formats SSL errors nicely and suggests to use `knife ssl check` and `knife ssl fetch`" do
+      error = OpenSSL::SSL::SSLError.new("SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed")
+      allow(knife).to receive(:run).and_raise(error)
+
+      knife.run_with_pretty_exceptions
+
+      expected_message=<<-MSG
+ERROR: Could not establish a secure connection to the server.
+Use `knife ssl check` to troubleshoot your SSL configuration.
+If your Chef Server uses a self-signed certificate, you can use
+`knife ssl fetch` to make knife trust the server's certificates.
+MSG
+      expect(stderr.string).to include(expected_message)
+    end
+
   end
 
 end