chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

data/spec/unit/application/apply_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Bryan W. Berry (<bryan.berry@gmail.com>)
-# Copyright:: Copyright (c) 2012 Bryan W. Berry
+# Copyright:: Copyright 2012-2016, Bryan W. Berry
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Application::Apply do
 
@@ -92,7 +92,7 @@ describe Chef::Application::Apply do
 
   end
   describe "when the json_attribs configuration option is specified" do
-    let(:json_attribs) { {"a" => "b"} }
+    let(:json_attribs) { { "a" => "b" } }
     let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
     let(:json_source) { "https://foo.com/foo.json" }
 

data/spec/unit/application/client_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Application::Client, "reconfigure" do
   let(:app) do
@@ -36,14 +36,18 @@ describe Chef::Application::Client, "reconfigure" do
     Chef::Config[:interval] = 10
 
     Chef::Config[:once] = false
+
+    # protect the unit tests against accidental --delete-entire-chef-repo from firing
+    # for real during tests.  DO NOT delete this line.
+    expect(FileUtils).not_to receive(:rm_rf)
   end
 
   after do
     ARGV.replace(@original_argv)
   end
 
-  describe 'parse cli_arguments' do
-    it 'should call set_specific_recipes' do
+  describe "parse cli_arguments" do
+    it "should call set_specific_recipes" do
       expect(app).to receive(:set_specific_recipes).and_return(true)
       app.reconfigure
     end
@@ -51,7 +55,7 @@ describe Chef::Application::Client, "reconfigure" do
     context "when given a named_run_list" do
 
       before do
-        ARGV.replace( %w[ --named-run-list arglebargle-example ] )
+        ARGV.replace( %w{ --named-run-list arglebargle-example } )
         app.reconfigure
       end
 
@@ -156,7 +160,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
 
   describe "when the json_attribs configuration option is specified" do
 
-    let(:json_attribs) { {"a" => "b"} }
+    let(:json_attribs) { { "a" => "b" } }
     let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
     let(:json_source) { "https://foo.com/foo.json" }
 
@@ -255,7 +259,6 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
   end
 end
 
-
 describe Chef::Application::Client, "setup_application" do
   before do
     @app = Chef::Application::Client.new
@@ -310,9 +313,9 @@ describe Chef::Application::Client, "run_application", :unix_only do
     @client = Chef::Client.new
     allow(Chef::Client).to receive(:new).and_return(@client)
     allow(@client).to receive(:run) do
-      @pipe[1].puts 'started'
+      @pipe[1].puts "started"
       sleep 1
-      @pipe[1].puts 'finished'
+      @pipe[1].puts "finished"
     end
   end
 

data/spec/unit/application/knife_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright 2008-2016, Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
+require "spec_helper"
 require "#{CHEF_SPEC_DATA}/knife_subcommand/test_yourself"
 
 describe Chef::Application::Knife do
@@ -82,9 +82,61 @@ describe Chef::Application::Knife do
     end
   end
 
+  context "when given fips flags" do
+    context "when Chef::Config[:fips]=false" do
+      before do
+        # This is required because the chef-fips pipeline does
+        # has a default value of true for fips
+        Chef::Config[:fips] = false
+      end
+
+      it "does not initialize fips mode when no flags are passed" do
+        with_argv(*%w{noop knife command}) do
+          expect(@knife).to receive(:exit).with(0)
+          expect(Chef::Config).not_to receive(:enable_fips_mode)
+          @knife.run
+          expect(Chef::Config[:fips]).to eq(false)
+        end
+      end
+
+      it "overwrites the Chef::Config value when passed --fips" do
+        with_argv(*%w{noop knife command --fips}) do
+          expect(@knife).to receive(:exit).with(0)
+          expect(Chef::Config).to receive(:enable_fips_mode)
+          @knife.run
+          expect(Chef::Config[:fips]).to eq(true)
+        end
+      end
+    end
+
+    context "when Chef::Config[:fips]=true" do
+      before do
+        Chef::Config[:fips] = true
+      end
+
+      it "initializes fips mode when passed --fips" do
+        with_argv(*%w{noop knife command --fips}) do
+          expect(@knife).to receive(:exit).with(0)
+          expect(Chef::Config).to receive(:enable_fips_mode)
+          @knife.run
+          expect(Chef::Config[:fips]).to eq(true)
+        end
+      end
+
+      it "overwrites the Chef::Config value when passed --no-fips" do
+        with_argv(*%w{noop knife command --no-fips}) do
+          expect(@knife).to receive(:exit).with(0)
+          expect(Chef::Config).not_to receive(:enable_fips_mode)
+          @knife.run
+          expect(Chef::Config[:fips]).to eq(false)
+        end
+      end
+    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'
+      relative_path = ".chef/client.pem"
       allow(Dir).to receive(:pwd).and_return(CHEF_SPEC_DATA)
       with_argv(*%W{noop knife command -k #{relative_path}}) do
         expect(@knife).to receive(:exit).with(0)
@@ -94,20 +146,20 @@ describe Chef::Application::Knife do
     end
 
     it "expands a ~/home/path to the correct full path" do
-      home_path = '~/.chef/client.pem'
+      home_path = "~/.chef/client.pem"
       with_argv(*%W{noop knife command -k #{home_path}}) do
         expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      expect(Chef::Config[:client_key]).to eq(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
       full_path = if windows?
-        'C:/chef/client.pem'
-      else
-        '/etc/chef/client.pem'
-      end
+                    "C:/chef/client.pem"
+                  else
+                    "/etc/chef/client.pem"
+                  end
       with_argv(*%W{noop knife command -k #{full_path}}) do
         expect(@knife).to receive(:exit).with(0)
         @knife.run
@@ -130,38 +182,38 @@ describe Chef::Application::Knife do
     end
 
     it "should load the environment from the config file" do
-      config_file = File.join(CHEF_SPEC_DATA,"environment-config.rb")
+      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
       with_argv(*%W{noop knife command -c #{config_file}}) do
         expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      expect(Chef::Config[:environment]).to eq('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
+      with_argv(*%w{noop knife command -E development}) do
         expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      expect(Chef::Config[:environment]).to eq('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")
+      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
       with_argv(*%W{noop knife command -c #{config_file} -E override}) do
         expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      expect(Chef::Config[:environment]).to eq('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")
+      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
       with_argv(*%W{noop knife command -E override -c #{config_file}}) do
         expect(@knife).to receive(:exit).with(0)
         @knife.run
       end
-      expect(Chef::Config[:environment]).to eq('override')
+      expect(Chef::Config[:environment]).to eq("override")
     end
 
     it "should run a sub command with the applications command line option prototype" do

data/spec/unit/application/solo_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Application::Solo do
 
@@ -28,13 +28,16 @@ describe Chef::Application::Solo do
     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
+
+    # protect the unit tests against accidental --delete-entire-chef-repo from firing
+    # for real during tests.  DO NOT delete this line.
+    expect(FileUtils).not_to receive(:rm_rf)
   end
 
   describe "configuring the application" do
-    it 'should call set_specific_recipes' do
+    it "should call set_specific_recipes" do
       expect(app).to receive(:set_specific_recipes)
       app.reconfigure
     end
@@ -87,7 +90,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
     end
 
     describe "when the json_attribs configuration option is specified" do
-      let(:json_attribs) { {"a" => "b"} }
+      let(:json_attribs) { { "a" => "b" } }
       let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
       let(:json_source) { "https://foo.com/foo.json" }
 
@@ -103,61 +106,39 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
       end
     end
 
-    describe "when the recipe_url configuration option is specified" do
-      let(:tarfile) { StringIO.new("remote_tarball_content") }
-      let(:target_file) { StringIO.new }
-      let(:shellout) { double(run_command: nil, error!: nil, stdout: '') }
-     
-      before do
-        Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
-        Chef::Config[:recipe_url] = "http://junglist.gen.nz/recipes.tgz"
-
-        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)
+    it "downloads a tarball when the recipe_url configuration option is specified" do
+      Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
+      Chef::Config[:recipe_url] = "http://junglist.gen.nz/recipes.tgz"
 
-        allow(Mixlib::ShellOut).to receive(:new).and_return(shellout)
-      end
+      expect(FileUtils).to receive(:mkdir_p).with("#{Dir.tmpdir}/chef-solo").and_return(true)
 
-      it "should create the recipes path based on the parent of the cookbook path" do
-        expect(FileUtils).to receive(:mkdir_p).with("#{Dir.tmpdir}/chef-solo").and_return(true)
-        app.reconfigure
-      end
+      tarfile = StringIO.new("remote_tarball_content")
+      target_file = StringIO.new
 
-      it "should download the recipes" do
-        expect(app).to receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(tarfile)
-        app.reconfigure
-      end
+      expect(app).to receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(tarfile)
+      expect(File).to receive(:open).with("#{Dir.tmpdir}/chef-solo/recipes.tgz", "wb").and_yield(target_file)
 
-      it "should write the recipes to the target path" do
-        app.reconfigure
-        expect(target_file.string).to eq("remote_tarball_content")
-      end
+      shellout = instance_double("Mixlib::ShellOut", run_command: nil, error!: nil, stdout: "")
 
-      it "should untar the target file to the parent of the cookbook path" do
-        expect(Mixlib::ShellOut).to receive(:new).with("tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo")  
-        app.reconfigure
-      end
+      expect(app).to receive(:shell_out!).with("tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo").and_return(shellout)
+      app.reconfigure
+      expect(target_file.string).to eq("remote_tarball_content")
     end
-  end
 
-  describe "when the json_attribs and recipe_url configuration options are both specified" do
-    let(:json_attribs) { {"a" => "b"} }
-    let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
-    let(:json_source) { "https://foo.com/foo.json" }
+    it "fetches the recipe_url first when both json_attribs and recipe_url are specified" do
+      json_attribs = { "a" => "b" }
+      config_fetcher = instance_double("Chef::ConfigFetcher", :fetch_json => json_attribs)
 
-    before do
-      Chef::Config[:json_attribs] = json_source
+      Chef::Config[:json_attribs] = "https://foo.com/foo.json"
       Chef::Config[:recipe_url] = "http://icanhas.cheezburger.com/lolcats"
       Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
-      allow(FileUtils).to receive(:rm_rf).and_return(true)
-      allow(FileUtils).to receive(:mkdir_p).and_return(true)
+      expect(FileUtils).to receive(:mkdir_p).with("#{Dir.tmpdir}/chef-solo").and_return(true)
+
       allow(Chef::Mixin::Command).to receive(:run_command).and_return(true)
-    end
 
-    it "should fetch the recipe_url first" do
+      shellout = instance_double("Mixlib::ShellOut", run_command: nil, error!: nil, stdout: "")
+
+      expect(app).to receive(:shell_out!).with("tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo").and_return(shellout)
       expect(app).to receive(:fetch_recipe_tarball).ordered
       expect(Chef::ConfigFetcher).to receive(:new).ordered.and_return(config_fetcher)
       app.reconfigure

data/spec/unit/application_spec.rb

@@ -1,7 +1,7 @@
 #
 # Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Author:: Mark Mzyk (mmzyk@opscode.com)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Mark Mzyk (mmzyk@chef.io)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Application do
   before do
@@ -34,209 +34,229 @@ describe Chef::Application do
     ARGV.replace(@original_argv)
   end
 
-  describe "reconfigure" do
-    before do
-      @app = Chef::Application.new
-      allow(@app).to receive(:configure_chef).and_return(true)
-      allow(@app).to receive(:configure_logging).and_return(true)
-    end
-
-    it "should configure chef" do
-      expect(@app).to receive(:configure_chef).and_return(true)
-      @app.reconfigure
-    end
-
-    it "should configure logging" do
-      expect(@app).to receive(:configure_logging).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
+  context "when there are no configuration errors" do
 
-  describe Chef::Application do
     before do
-      @app = Chef::Application.new
+      expect(Chef::Log).to_not receive(:fatal)
+      expect(Chef::Application).to_not receive(:fatal!)
     end
 
-    describe "run" do
+    describe "reconfigure" do
       before do
-        allow(@app).to receive(:setup_application).and_return(true)
-        allow(@app).to receive(:run_application).and_return(true)
+        @app = Chef::Application.new
         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
-        expect(@app).to receive(:reconfigure).and_return(true)
-        @app.run
+      it "should configure chef" do
+        expect(@app).to receive(:configure_chef).and_return(true)
+        @app.reconfigure
       end
 
-      it "should setup the application before running it" do
-        expect(@app).to receive(:setup_application).and_return(true)
-        @app.run
+      it "should configure logging" do
+        expect(@app).to receive(:configure_logging).and_return(true)
+        @app.reconfigure
       end
 
-      it "should run the actual application" do
-        expect(@app).to receive(:run_application).and_return(true)
-        @app.run
+      it "should not receive set_specific_recipes" do
+        expect(@app).to_not receive(:set_specific_recipes)
+        @app.reconfigure
       end
     end
-  end
 
-  describe "configure_chef" do
-    before do
-      # Silence warnings when no config file exists
-      allow(Chef::Log).to receive(:warn)
+    describe Chef::Application do
+      before do
+        @app = Chef::Application.new
+      end
 
-      @app = Chef::Application.new
-      #Chef::Config.stub(:merge!).and_return(true)
-      allow(@app).to receive(:parse_options).and_return(true)
-      expect(Chef::Config).to receive(:export_proxies).and_return(true)
-    end
+      describe "run" do
+        before do
+          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 parse the commandline options" do
-      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
+        it "should reconfigure the application before running" do
+          expect(@app).to receive(:reconfigure).and_return(true)
+          @app.run
+        end
 
-    describe "when a config_file is present" do
-      let(:config_content) { "rspec_ran('true')" }
-      let(:config_location) { "/etc/chef/default.rb" }
+        it "should setup the application before running it" do
+          expect(@app).to receive(:setup_application).and_return(true)
+          @app.run
+        end
 
-      let(:config_location_pathname) do
-        p = Pathname.new(config_location)
-        allow(p).to receive(:realpath).and_return(config_location)
-        p
+        it "should run the actual application" do
+          expect(@app).to receive(:run_application).and_return(true)
+          @app.run
+        end
       end
+    end
 
+    describe "configure_chef" do
       before do
-        @app.config[:config_file] = config_location
-
-        # force let binding to get evaluated or else we stub Pathname.new before we try to use it.
-        config_location_pathname
-        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)
+        # Silence warnings when no config file exists
+        allow(Chef::Log).to receive(:warn)
+
+        @app = Chef::Application.new
+        allow(@app).to receive(:parse_options).and_return(true)
+        expect(Chef::Config).to receive(:export_proxies).and_return(true)
       end
 
-      it "should configure chef::config from a file" do
-        expect(Chef::Config).to receive(:from_string).with(config_content, config_location)
+      it "should parse the commandline options" do
+        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
 
-      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
-        expect(Chef::Config.rspec_ran).to eq("true")
+      describe "when a config_file is present" do
+        let(:config_content) { "rspec_ran('true')" }
+        let(:config_location) { "/etc/chef/default.rb" }
+
+        let(:config_location_pathname) do
+          p = Pathname.new(config_location)
+          allow(p).to receive(:realpath).and_return(config_location)
+          p
+        end
+
+        before do
+          @app.config[:config_file] = config_location
+
+          # force let binding to get evaluated or else we stub Pathname.new before we try to use it.
+          config_location_pathname
+          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
+          expect(Chef::Config).to receive(:from_string).with(config_content, File.expand_path(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
+          expect(Chef::Config.rspec_ran).to eq("true")
+        end
+
+        context "when openssl fips" do
+          before do
+            allow(Chef::Config).to receive(:fips).and_return(true)
+          end
+
+          it "sets openssl in fips mode" do
+            expect(Chef::Config).to receive(:enable_fips_mode)
+            @app.configure_chef
+          end
+        end
       end
 
-    end
+      describe "when there is no config_file defined" do
+        before do
+          @app.config[:config_file] = nil
+        end
 
-    describe "when there is no config_file defined" do
-      before do
-        @app.config[:config_file] = nil
+        it "should emit a warning" do
+          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
 
-      it "should emit a warning" do
-        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
+      describe "when the config file is set and not found" do
+        before do
+          @app.config[:config_file] = "/etc/chef/notfound"
+        end
+        it "should use the passed in command line options and defaults" do
+          expect(Chef::Config).to receive(:merge!)
+          @app.configure_chef
+        end
       end
     end
 
-    describe "when the config file is set and not found" do
+    describe "when configuring the logger" do
       before do
-        @app.config[:config_file] = "/etc/chef/notfound"
+        @app = Chef::Application.new
+        allow(Chef::Log).to receive(:init)
       end
-      it "should use the passed in command line options and defaults" do
-        expect(Chef::Config).to receive(:merge!)
-        @app.configure_chef
+
+      it "should initialise the chef logger" do
+        allow(Chef::Log).to receive(:level=)
+        @monologger = double("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
-    end
-  end
 
-  describe "when configuring the logger" do
-    before do
-      @app = Chef::Application.new
-      allow(Chef::Log).to receive(:init)
-    end
+      shared_examples_for "log_level_is_auto" do
+        context "when STDOUT is to a tty" do
+          before do
+            allow(STDOUT).to receive(:tty?).and_return(true)
+          end
 
-    it "should initialise the chef logger" do
-      allow(Chef::Log).to receive(:level=)
-      @monologger = double("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 "configures the log level to :warn" do
+            @app.configure_logging
+            expect(Chef::Log.level).to eq(:warn)
+          end
 
-    it "should raise fatals if log location is invalid" do
-      Chef::Config[:log_location] = "/tmp/non-existing-dir/logfile"
-      expect(Chef::Log).to receive(:fatal).at_least(:once)
-      expect(Process).to receive(:exit)
-      @app.configure_logging
-    end
+          context "when force_logger is configured" do
+            before do
+              Chef::Config[:force_logger] = true
+            end
 
-    shared_examples_for "log_level_is_auto" do
-      context "when STDOUT is to a tty" do
-        before do
-          allow(STDOUT).to receive(:tty?).and_return(true)
-        end
-
-        it "configures the log level to :warn" do
-          @app.configure_logging
-          expect(Chef::Log.level).to eq(:warn)
+            it "configures the log level to info" do
+              @app.configure_logging
+              expect(Chef::Log.level).to eq(:info)
+            end
+          end
         end
 
-        context "when force_logger is configured" do
+        context "when STDOUT is not to a tty" do
           before do
-            Chef::Config[:force_logger] = true
+            allow(STDOUT).to receive(:tty?).and_return(false)
           end
 
-          it "configures the log level to info" do
+          it "configures the log level to :info" do
             @app.configure_logging
             expect(Chef::Log.level).to eq(:info)
           end
+
+          context "when force_formatter is configured" do
+            before do
+              Chef::Config[:force_formatter] = true
+            end
+            it "sets the log level to :warn" do
+              @app.configure_logging
+              expect(Chef::Log.level).to eq(:warn)
+            end
+          end
         end
       end
 
-      context "when STDOUT is not to a tty" do
-        before do
-          allow(STDOUT).to receive(:tty?).and_return(false)
-        end
+      context "when log_level is not set" do
+        it_behaves_like "log_level_is_auto"
+      end
 
-        it "configures the log level to :info" do
-          @app.configure_logging
-          expect(Chef::Log.level).to eq(:info)
+      context "when log_level is :auto" do
+        before do
+          Chef::Config[:log_level] = :auto
         end
 
-        context "when force_formatter is configured" do
-          before do
-            Chef::Config[:force_formatter] = true
-          end
-          it "sets the log level to :warn" do
-            @app.configure_logging
-            expect(Chef::Log.level).to eq(:warn)
-          end
-        end
+        it_behaves_like "log_level_is_auto"
       end
     end
+  end
 
-    context "when log_level is not set" do
-      it_behaves_like "log_level_is_auto"
-    end
+  context "with an invalid log location" do
 
-    context "when log_level is :auto" do
-      before do
-        Chef::Config[:log_level] = :auto
-      end
-
-      it_behaves_like "log_level_is_auto"
+    it "logs a fatal error and exits" do
+      Chef::Config[:log_location] = "/tmp/non-existing-dir/logfile"
+      expect(Chef::Log).to receive(:fatal).at_least(:once)
+      expect(Process).to receive(:exit)
+      @app.configure_logging
     end
   end
 
@@ -298,18 +318,18 @@ describe Chef::Application do
     end
   end
 
-  describe 'run_chef_client' do
-    context 'with an application' do
+  describe "run_chef_client" do
+    context "with an application" do
       let(:app) { Chef::Application.new }
 
-      context 'when called with an invalid argument' do
+      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'
+        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
@@ -320,7 +340,7 @@ describe Chef::Application do
           allow(app).to receive(:run_with_graceful_exit_option).and_return(true)
         end
 
-        it 'should be cool' do
+        it "should be cool" do
           expect { app.run_chef_client([]) }.not_to raise_error
         end
       end