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

data/spec/unit/application/knife_spec.rb

@@ -40,66 +40,66 @@ describe Chef::Application::Knife do
 
   before(:each) do
     # Prevent code from getting loaded on every test invocation.
-    Chef::Knife.stub(:load_commands)
+    allow(Chef::Knife).to receive(:load_commands)
 
     @knife = Chef::Application::Knife.new
-    @knife.stub(:puts)
-    @knife.stub(:trap)
-    Chef::Knife.stub(:list_commands)
+    allow(@knife).to receive(:puts)
+    allow(@knife).to receive(:trap)
+    allow(Chef::Knife).to receive(:list_commands)
   end
 
   it "should exit 1 and print the options if no arguments are given at all" do
     with_argv([]) do
-      lambda { @knife.run }.should raise_error(SystemExit) { |e| e.status.should == 1 }
+      expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
     end
   end
 
   it "should exit 2 if run without a sub command" do
     with_argv("--user", "adam") do
-      Chef::Log.should_receive(:error).with(/you need to pass a sub\-command/i)
-      lambda { @knife.run }.should raise_error(SystemExit) { |e| e.status.should == 2 }
+      expect(Chef::Log).to receive(:error).with(/you need to pass a sub\-command/i)
+      expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(2) }
     end
   end
 
   it "should run a sub command with the applications command line option prototype" do
     with_argv(*%w{noop knife command with some args}) do
       knife = double(Chef::Knife)
-      Chef::Knife.should_receive(:run).with(ARGV, @knife.options).and_return(knife)
-      @knife.should_receive(:exit).with(0)
+      expect(Chef::Knife).to receive(:run).with(ARGV, @knife.options).and_return(knife)
+      expect(@knife).to receive(:exit).with(0)
       @knife.run
     end
   end
 
   it "should set the colored output to false by default on windows and true otherwise" do
     with_argv(*%w{noop knife command}) do
-      @knife.should_receive(:exit).with(0)
+      expect(@knife).to receive(:exit).with(0)
       @knife.run
     end
     if windows?
-      Chef::Config[:color].should be_false
+      expect(Chef::Config[:color]).to be_falsey
     else
-      Chef::Config[:color].should be_true
+      expect(Chef::Config[:color]).to be_truthy
     end
   end
 
   describe "when given a path to the client key" do
     it "expands a relative path relative to the CWD" do
       relative_path = '.chef/client.pem'
-      Dir.stub(:pwd).and_return(CHEF_SPEC_DATA)
+      allow(Dir).to receive(:pwd).and_return(CHEF_SPEC_DATA)
       with_argv(*%W{noop knife command -k #{relative_path}}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:client_key].should == File.join(CHEF_SPEC_DATA, relative_path)
+      expect(Chef::Config[:client_key]).to eq(File.join(CHEF_SPEC_DATA, relative_path))
     end
 
     it "expands a ~/home/path to the correct full path" do
       home_path = '~/.chef/client.pem'
       with_argv(*%W{noop knife command -k #{home_path}}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:client_key].should == File.join(ENV['HOME'], '.chef/client.pem').gsub((File::ALT_SEPARATOR || '\\'), File::SEPARATOR)
+      expect(Chef::Config[:client_key]).to eq(File.join(ENV['HOME'], '.chef/client.pem').gsub((File::ALT_SEPARATOR || '\\'), File::SEPARATOR))
     end
 
     it "does not expand a full path" do
@@ -109,10 +109,10 @@ describe Chef::Application::Knife do
         '/etc/chef/client.pem'
       end
       with_argv(*%W{noop knife command -k #{full_path}}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:client_key].should == full_path
+      expect(Chef::Config[:client_key]).to eq(full_path)
     end
   end
 
@@ -123,52 +123,52 @@ describe Chef::Application::Knife do
 
     it "should default to no environment" do
       with_argv(*%w{noop knife command}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:environment].should == nil
+      expect(Chef::Config[:environment]).to eq(nil)
     end
 
     it "should load the environment from the config file" do
       config_file = File.join(CHEF_SPEC_DATA,"environment-config.rb")
       with_argv(*%W{noop knife command -c #{config_file}}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:environment].should == 'production'
+      expect(Chef::Config[:environment]).to eq('production')
     end
 
     it "should load the environment from the CLI options" do
       with_argv(*%W{noop knife command -E development}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:environment].should == 'development'
+      expect(Chef::Config[:environment]).to eq('development')
     end
 
     it "should override the config file environment with the CLI environment" do
       config_file = File.join(CHEF_SPEC_DATA,"environment-config.rb")
       with_argv(*%W{noop knife command -c #{config_file} -E override}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:environment].should == 'override'
+      expect(Chef::Config[:environment]).to eq('override')
     end
 
     it "should override the config file environment with the CLI environment regardless of order" do
       config_file = File.join(CHEF_SPEC_DATA,"environment-config.rb")
       with_argv(*%W{noop knife command -E override -c #{config_file}}) do
-        @knife.should_receive(:exit).with(0)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      Chef::Config[:environment].should == 'override'
+      expect(Chef::Config[:environment]).to eq('override')
     end
 
     it "should run a sub command with the applications command line option prototype" do
       with_argv(*%w{noop knife command with some args}) do
         knife = double(Chef::Knife)
-        Chef::Knife.should_receive(:run).with(ARGV, @knife.options).and_return(knife)
-        @knife.should_receive(:exit).with(0)
+        expect(Chef::Knife).to receive(:run).with(ARGV, @knife.options).and_return(knife)
+        expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
     end

data/spec/unit/application/solo_spec.rb

@@ -18,22 +18,35 @@
 require 'spec_helper'
 
 describe Chef::Application::Solo do
+
+  let(:app) { Chef::Application::Solo.new }
+
   before do
-    Kernel.stub(:trap).and_return(:ok)
-    @app = Chef::Application::Solo.new
-    @app.stub(:configure_opt_parser).and_return(true)
-    @app.stub(:configure_chef).and_return(true)
-    @app.stub(:configure_logging).and_return(true)
-    @app.stub(:trap)
+    allow(Kernel).to receive(:trap).and_return(:ok)
+    allow(app).to receive(:configure_opt_parser).and_return(true)
+    allow(app).to receive(:configure_chef).and_return(true)
+    allow(app).to receive(:configure_logging).and_return(true)
+    allow(app).to receive(:trap)
+
     Chef::Config[:recipe_url] = false
     Chef::Config[:json_attribs] = false
     Chef::Config[:solo] = true
   end
 
   describe "configuring the application" do
+    it 'should call set_specific_recipes' do
+      expect(app).to receive(:set_specific_recipes)
+      app.reconfigure
+    end
+
     it "should set solo mode to true" do
-      @app.reconfigure
-      Chef::Config[:solo].should be_true
+      app.reconfigure
+      expect(Chef::Config[:solo]).to be_truthy
+    end
+
+    it "should set audit-mode to :disabled" do
+      app.reconfigure
+      expect(Chef::Config[:audit_mode]).to be :disabled
     end
 
     describe "when configured to not fork the client process" do
@@ -50,13 +63,13 @@ describe Chef::Application::Solo do
         end
 
         it "should terminate with message" do
-          Chef::Application.should_receive(:fatal!).with(
+          expect(Chef::Application).to receive(:fatal!).with(
 "Unforked chef-client interval runs are disabled in Chef 12.
 Configuration settings:
   interval  = 600 seconds
 Enable chef-client interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
           )
-          @app.reconfigure
+          app.reconfigure
         end
       end
     end
@@ -68,8 +81,8 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
 
       it "should set the interval to 1800" do
         Chef::Config[:interval] = nil
-        @app.reconfigure
-        Chef::Config[:interval].should == 1800
+        app.reconfigure
+        expect(Chef::Config[:interval]).to eq(1800)
       end
     end
 
@@ -80,48 +93,51 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
 
       before do
         Chef::Config[:json_attribs] = json_source
-        Chef::ConfigFetcher.should_receive(:new).with(json_source).
+        expect(Chef::ConfigFetcher).to receive(:new).with(json_source).
           and_return(config_fetcher)
       end
 
       it "reads the JSON attributes from the specified source" do
-        @app.reconfigure
-        @app.chef_client_json.should == json_attribs
+        app.reconfigure
+        expect(app.chef_client_json).to eq(json_attribs)
       end
     end
 
     describe "when the recipe_url configuration option is specified" do
+      let(:tarfile) { StringIO.new("remote_tarball_content") }
+      let(:target_file) { StringIO.new }
+
       before do
         Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
         Chef::Config[:recipe_url] = "http://junglist.gen.nz/recipes.tgz"
-        FileUtils.stub(:mkdir_p).and_return(true)
-        @tarfile = StringIO.new("remote_tarball_content")
-        @app.stub(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(@tarfile)
 
-        @target_file = StringIO.new
-        File.stub(:open).with("#{Dir.tmpdir}/chef-solo/recipes.tgz", "wb").and_yield(@target_file)
+        allow(FileUtils).to receive(:rm_rf).and_return(true)
+        allow(FileUtils).to receive(:mkdir_p).and_return(true)
+
+        allow(app).to receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(tarfile)
+        allow(File).to receive(:open).with("#{Dir.tmpdir}/chef-solo/recipes.tgz", "wb").and_yield(target_file)
 
-        Chef::Mixin::Command.stub(:run_command).and_return(true)
+        allow(Chef::Mixin::Command).to receive(:run_command).and_return(true)
       end
 
       it "should create the recipes path based on the parent of the cookbook path" do
-        FileUtils.should_receive(:mkdir_p).with("#{Dir.tmpdir}/chef-solo").and_return(true)
-        @app.reconfigure
+        expect(FileUtils).to receive(:mkdir_p).with("#{Dir.tmpdir}/chef-solo").and_return(true)
+        app.reconfigure
       end
 
       it "should download the recipes" do
-        @app.should_receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(@tarfile)
-        @app.reconfigure
+        expect(app).to receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(tarfile)
+        app.reconfigure
       end
 
       it "should write the recipes to the target path" do
-        @app.reconfigure
-        @target_file.string.should == "remote_tarball_content"
+        app.reconfigure
+        expect(target_file.string).to eq("remote_tarball_content")
       end
 
       it "should untar the target file to the parent of the cookbook path" do
-        Chef::Mixin::Command.should_receive(:run_command).with({:command => "tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo"}).and_return(true)
-        @app.reconfigure
+        expect(Chef::Mixin::Command).to receive(:run_command).with({:command => "tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo"}).and_return(true)
+        app.reconfigure
       end
     end
   end
@@ -135,14 +151,15 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
       Chef::Config[:json_attribs] = json_source
       Chef::Config[:recipe_url] = "http://icanhas.cheezburger.com/lolcats"
       Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
-      FileUtils.stub(:mkdir_p).and_return(true)
-      Chef::Mixin::Command.stub(:run_command).and_return(true)
+      allow(FileUtils).to receive(:rm_rf).and_return(true)
+      allow(FileUtils).to receive(:mkdir_p).and_return(true)
+      allow(Chef::Mixin::Command).to receive(:run_command).and_return(true)
     end
 
     it "should fetch the recipe_url first" do
-      @app.should_receive(:fetch_recipe_tarball).ordered
-      Chef::ConfigFetcher.should_receive(:new).ordered.and_return(config_fetcher)
-      @app.reconfigure
+      expect(app).to receive(:fetch_recipe_tarball).ordered
+      expect(Chef::ConfigFetcher).to receive(:new).ordered.and_return(config_fetcher)
+      app.reconfigure
     end
   end
 
@@ -150,19 +167,18 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
     before do
       Chef::Config[:solo] = true
 
-      Chef::Daemon.stub(:change_privilege)
-      @chef_client = double("Chef::Client")
-      Chef::Client.stub(:new).and_return(@chef_client)
-      @app = Chef::Application::Solo.new
+      allow(Chef::Daemon).to receive(:change_privilege)
+      chef_client = double("Chef::Client")
+      allow(Chef::Client).to receive(:new).and_return(chef_client)
       # this is all stuff the reconfigure method needs
-      @app.stub(:configure_opt_parser).and_return(true)
-      @app.stub(:configure_chef).and_return(true)
-      @app.stub(:configure_logging).and_return(true)
+      allow(app).to receive(:configure_opt_parser).and_return(true)
+      allow(app).to receive(:configure_chef).and_return(true)
+      allow(app).to receive(:configure_logging).and_return(true)
     end
 
     it "should change privileges" do
-      Chef::Daemon.should_receive(:change_privilege).and_return(true)
-      @app.setup_application
+      expect(Chef::Daemon).to receive(:change_privilege).and_return(true)
+      app.setup_application
     end
   end
 

data/spec/unit/application_spec.rb

@@ -24,9 +24,9 @@ describe Chef::Application do
     ARGV.clear
     Chef::Log.logger = Logger.new(StringIO.new)
     @app = Chef::Application.new
-    @app.stub(:trap)
-    Dir.stub(:chdir).and_return(0)
-    @app.stub(:reconfigure)
+    allow(@app).to receive(:trap)
+    allow(Dir).to receive(:chdir).and_return(0)
+    allow(@app).to receive(:reconfigure)
     Chef::Log.init(STDERR)
   end
 
@@ -37,23 +37,28 @@ describe Chef::Application do
   describe "reconfigure" do
     before do
       @app = Chef::Application.new
-      @app.stub(:configure_chef).and_return(true)
-      @app.stub(:configure_logging).and_return(true)
-      @app.stub(:configure_proxy_environment_variables).and_return(true)
+      allow(@app).to receive(:configure_chef).and_return(true)
+      allow(@app).to receive(:configure_logging).and_return(true)
+      allow(@app).to receive(:configure_proxy_environment_variables).and_return(true)
     end
 
     it "should configure chef" do
-      @app.should_receive(:configure_chef).and_return(true)
+      expect(@app).to receive(:configure_chef).and_return(true)
       @app.reconfigure
     end
 
     it "should configure logging" do
-      @app.should_receive(:configure_logging).and_return(true)
+      expect(@app).to receive(:configure_logging).and_return(true)
       @app.reconfigure
     end
 
     it "should configure environment variables" do
-      @app.should_receive(:configure_proxy_environment_variables).and_return(true)
+      expect(@app).to receive(:configure_proxy_environment_variables).and_return(true)
+      @app.reconfigure
+    end
+
+    it 'should not receive set_specific_recipes' do
+      expect(@app).to_not receive(:set_specific_recipes)
       @app.reconfigure
     end
   end
@@ -65,24 +70,24 @@ describe Chef::Application do
 
     describe "run" do
       before do
-        @app.stub(:setup_application).and_return(true)
-        @app.stub(:run_application).and_return(true)
-        @app.stub(:configure_chef).and_return(true)
-        @app.stub(:configure_logging).and_return(true)
+        allow(@app).to receive(:setup_application).and_return(true)
+        allow(@app).to receive(:run_application).and_return(true)
+        allow(@app).to receive(:configure_chef).and_return(true)
+        allow(@app).to receive(:configure_logging).and_return(true)
       end
 
       it "should reconfigure the application before running" do
-        @app.should_receive(:reconfigure).and_return(true)
+        expect(@app).to receive(:reconfigure).and_return(true)
         @app.run
       end
 
       it "should setup the application before running it" do
-        @app.should_receive(:setup_application).and_return(true)
+        expect(@app).to receive(:setup_application).and_return(true)
         @app.run
       end
 
       it "should run the actual application" do
-        @app.should_receive(:run_application).and_return(true)
+        expect(@app).to receive(:run_application).and_return(true)
         @app.run
       end
     end
@@ -91,15 +96,15 @@ describe Chef::Application do
   describe "configure_chef" do
     before do
       # Silence warnings when no config file exists
-      Chef::Log.stub(:warn)
+      allow(Chef::Log).to receive(:warn)
 
       @app = Chef::Application.new
       #Chef::Config.stub(:merge!).and_return(true)
-      @app.stub(:parse_options).and_return(true)
+      allow(@app).to receive(:parse_options).and_return(true)
     end
 
     it "should parse the commandline options" do
-      @app.should_receive(:parse_options).and_return(true)
+      expect(@app).to receive(:parse_options).and_return(true)
       @app.config[:config_file] = "/etc/chef/default.rb" #have a config file set, to prevent triggering error block
       @app.configure_chef
     end
@@ -110,7 +115,7 @@ describe Chef::Application do
 
       let(:config_location_pathname) do
         p = Pathname.new(config_location)
-        p.stub(:realpath).and_return(config_location)
+        allow(p).to receive(:realpath).and_return(config_location)
         p
       end
 
@@ -119,21 +124,21 @@ describe Chef::Application do
 
         # force let binding to get evaluated or else we stub Pathname.new before we try to use it.
         config_location_pathname
-        Pathname.stub(:new).with(config_location).and_return(config_location_pathname)
-        File.should_receive(:read).
+        allow(Pathname).to receive(:new).with(config_location).and_return(config_location_pathname)
+        expect(File).to receive(:read).
           with(config_location).
           and_return(config_content)
       end
 
       it "should configure chef::config from a file" do
-        Chef::Config.should_receive(:from_string).with(config_content, config_location)
+        expect(Chef::Config).to receive(:from_string).with(config_content, config_location)
         @app.configure_chef
       end
 
       it "should merge the local config hash into chef::config" do
         #File.should_receive(:open).with("/etc/chef/default.rb").and_yield(@config_file)
         @app.configure_chef
-        Chef::Config.rspec_ran.should == "true"
+        expect(Chef::Config.rspec_ran).to eq("true")
       end
 
     end
@@ -144,8 +149,8 @@ describe Chef::Application do
       end
 
       it "should emit a warning" do
-        Chef::Config.should_not_receive(:from_file).with("/etc/chef/default.rb")
-        Chef::Log.should_receive(:warn).with("No config file found or specified on command line, using command line options.")
+        expect(Chef::Config).not_to receive(:from_file).with("/etc/chef/default.rb")
+        expect(Chef::Log).to receive(:warn).with("No config file found or specified on command line, using command line options.")
         @app.configure_chef
       end
     end
@@ -155,7 +160,7 @@ describe Chef::Application do
         @app.config[:config_file] = "/etc/chef/notfound"
       end
       it "should use the passed in command line options and defaults" do
-        Chef::Config.should_receive(:merge!)
+        expect(Chef::Config).to receive(:merge!)
         @app.configure_chef
       end
     end
@@ -164,33 +169,33 @@ describe Chef::Application do
   describe "when configuring the logger" do
     before do
       @app = Chef::Application.new
-      Chef::Log.stub(:init)
+      allow(Chef::Log).to receive(:init)
     end
 
     it "should initialise the chef logger" do
-      Chef::Log.stub(:level=)
+      allow(Chef::Log).to receive(:level=)
       @monologger = double("Monologger")
-      MonoLogger.should_receive(:new).with(Chef::Config[:log_location]).and_return(@monologger)
-      Chef::Log.should_receive(:init).with(@monologger)
+      expect(MonoLogger).to receive(:new).with(Chef::Config[:log_location]).and_return(@monologger)
+      expect(Chef::Log).to receive(:init).with(@monologger)
       @app.configure_logging
     end
 
     it "should raise fatals if log location is invalid" do
       Chef::Config[:log_location] = "/tmp/non-existing-dir/logfile"
-      Chef::Log.should_receive(:fatal).at_least(:once)
-      Process.should_receive(:exit)
+      expect(Chef::Log).to receive(:fatal).at_least(:once)
+      expect(Process).to receive(:exit)
       @app.configure_logging
     end
 
     shared_examples_for "log_level_is_auto" do
       context "when STDOUT is to a tty" do
         before do
-          STDOUT.stub(:tty?).and_return(true)
+          allow(STDOUT).to receive(:tty?).and_return(true)
         end
 
         it "configures the log level to :warn" do
           @app.configure_logging
-          Chef::Log.level.should == :warn
+          expect(Chef::Log.level).to eq(:warn)
         end
 
         context "when force_logger is configured" do
@@ -200,19 +205,19 @@ describe Chef::Application do
 
           it "configures the log level to info" do
             @app.configure_logging
-            Chef::Log.level.should == :info
+            expect(Chef::Log.level).to eq(:info)
           end
         end
       end
 
       context "when STDOUT is not to a tty" do
         before do
-          STDOUT.stub(:tty?).and_return(false)
+          allow(STDOUT).to receive(:tty?).and_return(false)
         end
 
         it "configures the log level to :info" do
           @app.configure_logging
-          Chef::Log.level.should == :info
+          expect(Chef::Log.level).to eq(:info)
         end
 
         context "when force_formatter is configured" do
@@ -221,7 +226,7 @@ describe Chef::Application do
           end
           it "sets the log level to :warn" do
             @app.configure_logging
-            Chef::Log.level.should == :warn
+            expect(Chef::Log.level).to eq(:warn)
           end
         end
       end
@@ -242,10 +247,10 @@ describe Chef::Application do
 
   describe "when configuring environment variables" do
     def configure_proxy_environment_variables_stubs
-      @app.stub(:configure_http_proxy).and_return(true)
-      @app.stub(:configure_https_proxy).and_return(true)
-      @app.stub(:configure_ftp_proxy).and_return(true)
-      @app.stub(:configure_no_proxy).and_return(true)
+      allow(@app).to receive(:configure_http_proxy).and_return(true)
+      allow(@app).to receive(:configure_https_proxy).and_return(true)
+      allow(@app).to receive(:configure_ftp_proxy).and_return(true)
+      allow(@app).to receive(:configure_no_proxy).and_return(true)
     end
 
     shared_examples_for "setting ENV['http_proxy']" do
@@ -255,12 +260,12 @@ describe Chef::Application do
 
       it "should set ENV['http_proxy']" do
         @app.configure_proxy_environment_variables
-        @env['http_proxy'].should == "#{scheme}://#{address}:#{port}"
+        expect(@env['http_proxy']).to eq("#{scheme}://#{address}:#{port}")
       end
 
       it "should set ENV['HTTP_PROXY']" do
         @app.configure_proxy_environment_variables
-        @env['HTTP_PROXY'].should == "#{scheme}://#{address}:#{port}"
+        expect(@env['HTTP_PROXY']).to eq("#{scheme}://#{address}:#{port}")
       end
 
       describe "when Chef::Config[:http_proxy_user] is set" do
@@ -270,8 +275,8 @@ describe Chef::Application do
 
         it "should set ENV['http_proxy'] with the username" do
           @app.configure_proxy_environment_variables
-          @env['http_proxy'].should == "#{scheme}://username@#{address}:#{port}"
-          @env['HTTP_PROXY'].should == "#{scheme}://username@#{address}:#{port}"
+          expect(@env['http_proxy']).to eq("#{scheme}://username@#{address}:#{port}")
+          expect(@env['HTTP_PROXY']).to eq("#{scheme}://username@#{address}:#{port}")
         end
 
         context "when :http_proxy_user contains '@' and/or ':'" do
@@ -281,8 +286,8 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy'] with the escaped username" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == "#{scheme}://my%3Ausern%40me@#{address}:#{port}"
-            @env['HTTP_PROXY'].should == "#{scheme}://my%3Ausern%40me@#{address}:#{port}"
+            expect(@env['http_proxy']).to eq("#{scheme}://my%3Ausern%40me@#{address}:#{port}")
+            expect(@env['HTTP_PROXY']).to eq("#{scheme}://my%3Ausern%40me@#{address}:#{port}")
           end
         end
 
@@ -293,8 +298,8 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy'] with the password" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == "#{scheme}://username:password@#{address}:#{port}"
-            @env['HTTP_PROXY'].should == "#{scheme}://username:password@#{address}:#{port}"
+            expect(@env['http_proxy']).to eq("#{scheme}://username:password@#{address}:#{port}")
+            expect(@env['HTTP_PROXY']).to eq("#{scheme}://username:password@#{address}:#{port}")
           end
 
           context "when :http_proxy_pass contains '@' and/or ':'" do
@@ -304,8 +309,8 @@ describe Chef::Application do
 
             it "should set ENV['http_proxy'] with the escaped password" do
               @app.configure_proxy_environment_variables
-              @env['http_proxy'].should == "#{scheme}://username:%3AP%40ssword101@#{address}:#{port}"
-              @env['HTTP_PROXY'].should == "#{scheme}://username:%3AP%40ssword101@#{address}:#{port}"
+              expect(@env['http_proxy']).to eq("#{scheme}://username:%3AP%40ssword101@#{address}:#{port}")
+              expect(@env['HTTP_PROXY']).to eq("#{scheme}://username:%3AP%40ssword101@#{address}:#{port}")
             end
           end
         end
@@ -319,8 +324,8 @@ describe Chef::Application do
 
         it "should set ENV['http_proxy']" do
           @app.configure_proxy_environment_variables
-          @env['http_proxy'].should == "#{scheme}://#{address}:#{port}"
-          @env['HTTP_PROXY'].should == "#{scheme}://#{address}:#{port}"
+          expect(@env['http_proxy']).to eq("#{scheme}://#{address}:#{port}")
+          expect(@env['HTTP_PROXY']).to eq("#{scheme}://#{address}:#{port}")
         end
       end
     end
@@ -328,11 +333,11 @@ describe Chef::Application do
     describe "when configuring ENV['http_proxy']" do
       before do
         @env = {}
-        @app.stub(:env).and_return(@env)
+        allow(@app).to receive(:env).and_return(@env)
 
-        @app.stub(:configure_https_proxy).and_return(true)
-        @app.stub(:configure_ftp_proxy).and_return(true)
-        @app.stub(:configure_no_proxy).and_return(true)
+        allow(@app).to receive(:configure_https_proxy).and_return(true)
+        allow(@app).to receive(:configure_ftp_proxy).and_return(true)
+        allow(@app).to receive(:configure_no_proxy).and_return(true)
       end
 
       describe "when Chef::Config[:http_proxy] is not set" do
@@ -342,7 +347,7 @@ describe Chef::Application do
 
         it "should not set ENV['http_proxy']" do
           @app.configure_proxy_environment_variables
-          @env.should == {}
+          expect(@env).to eq({})
         end
       end
 
@@ -401,7 +406,7 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy']" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == Chef::Config[:http_proxy]
+            expect(@env['http_proxy']).to eq(Chef::Config[:http_proxy])
           end
         end
 
@@ -417,26 +422,26 @@ describe Chef::Application do
 
   describe "class method: fatal!" do
     before do
-      STDERR.stub(:puts).with("FATAL: blah").and_return(true)
-      Chef::Log.stub(:fatal).and_return(true)
-      Process.stub(:exit).and_return(true)
+      allow(STDERR).to receive(:puts).with("FATAL: blah").and_return(true)
+      allow(Chef::Log).to receive(:fatal).and_return(true)
+      allow(Process).to receive(:exit).and_return(true)
     end
 
     it "should log an error message to the logger" do
-      Chef::Log.should_receive(:fatal).with("blah").and_return(true)
+      expect(Chef::Log).to receive(:fatal).with("blah").and_return(true)
       Chef::Application.fatal! "blah"
     end
 
     describe "when an exit code is supplied" do
       it "should exit with the given exit code" do
-        Process.should_receive(:exit).with(-100).and_return(true)
+        expect(Process).to receive(:exit).with(-100).and_return(true)
         Chef::Application.fatal! "blah", -100
       end
     end
 
     describe "when an exit code is not supplied" do
       it "should exit with the default exit code" do
-        Process.should_receive(:exit).with(-1).and_return(true)
+        expect(Process).to receive(:exit).with(-1).and_return(true)
         Chef::Application.fatal! "blah"
       end
     end
@@ -449,7 +454,7 @@ describe Chef::Application do
     end
 
     it "should raise an error" do
-      lambda { @app.setup_application }.should raise_error(Chef::Exceptions::Application)
+      expect { @app.setup_application }.to raise_error(Chef::Exceptions::Application)
     end
   end
 
@@ -459,7 +464,7 @@ describe Chef::Application do
     end
 
     it "should raise an error" do
-      lambda { @app.run_application }.should raise_error(Chef::Exceptions::Application)
+      expect { @app.run_application }.to raise_error(Chef::Exceptions::Application)
     end
   end
 
@@ -467,22 +472,52 @@ describe Chef::Application do
     it "should warn for bad config file path" do
       @app.config[:config_file] = "/tmp/non-existing-dir/file"
       config_file_regexp = Regexp.new @app.config[:config_file]
-      Chef::Log.should_receive(:warn).at_least(:once).with(config_file_regexp).and_return(true)
-      Chef::Log.stub(:warn).and_return(true)
+      expect(Chef::Log).to receive(:warn).at_least(:once).with(config_file_regexp).and_return(true)
+      allow(Chef::Log).to receive(:warn).and_return(true)
       @app.configure_chef
     end
   end
 
+  describe 'run_chef_client' do
+    context 'with an application' do
+      let(:app) { Chef::Application.new }
+
+      context 'when called with an invalid argument' do
+        before do
+          allow(app).to receive(:fork_chef_client).and_return(true)
+          allow(app).to receive(:run_with_graceful_exit_option).and_return(true)
+        end
+
+        it 'should raise an argument error detailing the problem' do
+          specific_recipes_regexp = Regexp.new 'received non-Array like specific_recipes argument'
+          expect { app.run_chef_client(nil) }.to raise_error(ArgumentError, specific_recipes_regexp)
+        end
+      end
+
+      context 'when called with an Array-like argument (#size)' do
+        before do
+          allow(app).to receive(:fork_chef_client).and_return(true)
+          allow(app).to receive(:run_with_graceful_exit_option).and_return(true)
+        end
+
+        it 'should be cool' do
+          expect { app.run_chef_client([]) }.not_to raise_error
+        end
+      end
+    end
+
+  end
+
   describe "configuration errors" do
     before do
-      Process.should_receive(:exit)
+      expect(Process).to receive(:exit)
     end
 
     def raises_informative_fatals_on_configure_chef
       config_file_regexp = Regexp.new @app.config[:config_file]
-      Chef::Log.should_receive(:fatal).
+      expect(Chef::Log).to receive(:fatal).
         with(/Configuration error/)
-      Chef::Log.should_receive(:fatal).
+      expect(Chef::Log).to receive(:fatal).
         with(config_file_regexp).
         at_least(1).times
       @app.configure_chef