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

data/spec/unit/resource_resolver_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Ranjib Dey
-# Copyright:: Copyright (c) 2015 Ranjib Dey <ranjib@linux.com>.
+# Copyright:: Copyright 2015-2016, Ranjib Dey <ranjib@linux.com>.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,9 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/resource_resolver'
-
+require "spec_helper"
+require "chef/resource_resolver"
 
 describe Chef::ResourceResolver do
   it '#resolve' do
@@ -29,9 +28,9 @@ describe Chef::ResourceResolver do
     expect(described_class.list(:package)).to_not be_empty
   end
 
-  context 'instance methods' do
+  context "instance methods" do
     let(:resolver) do
-      described_class.new(Chef::Node.new, 'execute')
+      described_class.new(Chef::Node.new, "execute")
     end
 
     it '#resolve' do

data/spec/unit/resource_spec.rb

@@ -1,9 +1,9 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Copyright:: Copyright (c) 2008-2011 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Author:: Tim Hinderliter (<tim@chef.io>)
+# Author:: Seth Chisamore (<schisamo@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");
@@ -19,10 +19,10 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Resource do
-  let(:cookbook_repo_path) { File.join(CHEF_SPEC_DATA, 'cookbooks') }
+  let(:cookbook_repo_path) { File.join(CHEF_SPEC_DATA, "cookbooks") }
   let(:cookbook_collection) { Chef::CookbookCollection.new(Chef::CookbookLoader.new(cookbook_repo_path)) }
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
@@ -205,7 +205,7 @@ describe Chef::Resource do
     end
 
     it "coerces arrays to names" do
-      expect(resource.name ['a', 'b']).to eql('a, b')
+      expect(resource.name ["a", "b"]).to eql("a, b")
     end
 
     it "should coerce objects to a string" do
@@ -225,13 +225,13 @@ describe Chef::Resource do
     it "should make notified resources appear in the actions hash" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
       resource.notifies :reload, run_context.resource_collection.find(:zen_master => "coffee")
-      expect(resource.delayed_notifications.detect{|e| e.resource.name == "coffee" && e.action == :reload}).not_to be_nil
+      expect(resource.delayed_notifications.detect { |e| e.resource.name == "coffee" && e.action == :reload }).not_to be_nil
     end
 
     it "should make notified resources be capable of acting immediately" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
       resource.notifies :reload, run_context.resource_collection.find(:zen_master => "coffee"), :immediate
-      expect(resource.immediate_notifications.detect{|e| e.resource.name == "coffee" && e.action == :reload}).not_to be_nil
+      expect(resource.immediate_notifications.detect { |e| e.resource.name == "coffee" && e.action == :reload }).not_to be_nil
     end
 
     it "should raise an exception if told to act in other than :delay or :immediate(ly)" do
@@ -244,35 +244,35 @@ describe Chef::Resource do
     it "should allow multiple notified resources appear in the actions hash" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
       resource.notifies :reload, run_context.resource_collection.find(:zen_master => "coffee")
-      expect(resource.delayed_notifications.detect{|e| e.resource.name == "coffee" && e.action == :reload}).not_to be_nil
+      expect(resource.delayed_notifications.detect { |e| e.resource.name == "coffee" && e.action == :reload }).not_to be_nil
 
       run_context.resource_collection << Chef::Resource::ZenMaster.new("beans")
       resource.notifies :reload, run_context.resource_collection.find(:zen_master => "beans")
-      expect(resource.delayed_notifications.detect{|e| e.resource.name == "beans" && e.action == :reload}).not_to be_nil
+      expect(resource.delayed_notifications.detect { |e| e.resource.name == "beans" && e.action == :reload }).not_to be_nil
     end
 
     it "creates a notification for a resource that is not yet in the resource collection" do
-      resource.notifies(:restart, :service => 'apache')
-      expected_notification = Chef::Resource::Notification.new({:service => "apache"}, :restart, resource)
+      resource.notifies(:restart, :service => "apache")
+      expected_notification = Chef::Resource::Notification.new({ :service => "apache" }, :restart, resource)
       expect(resource.delayed_notifications).to include(expected_notification)
     end
 
     it "notifies another resource immediately" do
-      resource.notifies_immediately(:restart, :service => 'apache')
-      expected_notification = Chef::Resource::Notification.new({:service => "apache"}, :restart, resource)
+      resource.notifies_immediately(:restart, :service => "apache")
+      expected_notification = Chef::Resource::Notification.new({ :service => "apache" }, :restart, resource)
       expect(resource.immediate_notifications).to include(expected_notification)
     end
 
     it "notifies a resource to take action at the end of the chef run" do
       resource.notifies_delayed(:restart, :service => "apache")
-      expected_notification = Chef::Resource::Notification.new({:service => "apache"}, :restart, resource)
+      expected_notification = Chef::Resource::Notification.new({ :service => "apache" }, :restart, resource)
       expect(resource.delayed_notifications).to include(expected_notification)
     end
 
     it "notifies a resource with an array for its name via its prettified string name" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new(["coffee", "tea"])
       resource.notifies :reload, run_context.resource_collection.find(:zen_master => "coffee, tea")
-      expect(resource.delayed_notifications.detect{|e| e.resource.name == "coffee, tea" && e.action == :reload}).not_to be_nil
+      expect(resource.delayed_notifications.detect { |e| e.resource.name == "coffee, tea" && e.action == :reload }).not_to be_nil
     end
   end
 
@@ -281,26 +281,26 @@ describe Chef::Resource do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
       zr = run_context.resource_collection.find(:zen_master => "coffee")
       resource.subscribes :reload, zr
-      expect(zr.delayed_notifications.detect{|e| e.resource.name == "funk" && e.action == :reload}).not_to be_nil
+      expect(zr.delayed_notifications.detect { |e| e.resource.name == "funk" && e.action == :reload }).not_to be_nil
     end
 
     it "should make resources appear in the actions hash of subscribed nodes" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
       zr = run_context.resource_collection.find(:zen_master => "coffee")
       resource.subscribes :reload, zr
-      expect(zr.delayed_notifications.detect{|e| e.resource.name == resource.name && e.action == :reload}).not_to be_nil
+      expect(zr.delayed_notifications.detect { |e| e.resource.name == resource.name && e.action == :reload }).not_to be_nil
 
       run_context.resource_collection << Chef::Resource::ZenMaster.new("bean")
       zrb = run_context.resource_collection.find(:zen_master => "bean")
       zrb.subscribes :reload, zr
-      expect(zr.delayed_notifications.detect{|e| e.resource.name == resource.name && e.action == :reload}).not_to be_nil
+      expect(zr.delayed_notifications.detect { |e| e.resource.name == resource.name && e.action == :reload }).not_to be_nil
     end
 
     it "should make subscribed resources be capable of acting immediately" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
       zr = run_context.resource_collection.find(:zen_master => "coffee")
       resource.subscribes :reload, zr, :immediately
-      expect(zr.immediate_notifications.detect{|e| e.resource.name == resource.name && e.action == :reload}).not_to be_nil
+      expect(zr.immediate_notifications.detect { |e| e.resource.name == resource.name && e.action == :reload }).not_to be_nil
     end
   end
 
@@ -340,7 +340,7 @@ describe Chef::Resource do
         c = Class.new(Chef::Resource) do
         end
 
-        r = c.new('hi')
+        r = c.new("hi")
         r.declared_type = :d
         expect(c.resource_name).to be_nil
         expect(r.resource_name).to be_nil
@@ -355,7 +355,7 @@ describe Chef::Resource do
           end
         end
 
-        r = c.new('hi')
+        r = c.new("hi")
         r.declared_type = :d
         expect(c.resource_name).to be_nil
         expect(r.resource_name).to eq :blah
@@ -369,7 +369,7 @@ describe Chef::Resource do
           end
         end
 
-        r = c.new('hi')
+        r = c.new("hi")
         r.declared_type = :d
         expect(c.resource_name).to be_nil
         expect(r.resource_name).to be_nil
@@ -379,10 +379,10 @@ describe Chef::Resource do
 
     it "resource_name without provides is honored" do
       c = Class.new(Chef::Resource) do
-        resource_name 'blah'
+        resource_name "blah"
       end
 
-      r = c.new('hi')
+      r = c.new("hi")
       r.declared_type = :d
       expect(c.resource_name).to eq :blah
       expect(r.resource_name).to eq :blah
@@ -394,7 +394,7 @@ describe Chef::Resource do
       end
       c.resource_name = :blah
 
-      r = c.new('hi')
+      r = c.new("hi")
       r.declared_type = :d
       expect(c.resource_name).to eq :blah
       expect(r.resource_name).to eq :blah
@@ -406,7 +406,7 @@ describe Chef::Resource do
         provides :self_resource_name_test_3
       end
 
-      r = c.new('hi')
+      r = c.new("hi")
       r.declared_type = :d
       expect(c.resource_name).to eq :blah
       expect(r.resource_name).to eq :blah
@@ -417,7 +417,7 @@ describe Chef::Resource do
   describe "is" do
     it "should return the arguments passed with 'is'" do
       zm = Chef::Resource::ZenMaster.new("coffee")
-      expect(zm.is("one", "two", "three")).to eq(%w|one two three|)
+      expect(zm.is("one", "two", "three")).to eq(%w{one two three})
     end
 
     it "should allow arguments preceded by is to methods" do
@@ -512,7 +512,7 @@ describe Chef::Resource do
 
     before do
       node.automatic_attrs[:platform] = "fubuntu"
-      node.automatic_attrs[:platform_version] = '10.04'
+      node.automatic_attrs[:platform_version] = "10.04"
     end
 
     it "should default to not retrying if a provider fails for a resource" do
@@ -614,7 +614,7 @@ describe Chef::Resource do
     }
     before do
       node.automatic_attrs[:platform] = "fubuntu"
-      node.automatic_attrs[:platform_version] = '10.04'
+      node.automatic_attrs[:platform_version] = "10.04"
     end
 
     it "does not run only_if if no only_if command is given" do
@@ -643,8 +643,8 @@ describe Chef::Resource do
 
     it "accepts command options for only_if conditionals" do
       expect_any_instance_of(Chef::Resource::Conditional).to receive(:evaluate_command).at_least(1).times
-      resource.only_if("true", :cwd => '/tmp')
-      expect(resource.only_if.first.command_opts).to eq({:cwd => '/tmp'})
+      resource.only_if("true", :cwd => "/tmp")
+      expect(resource.only_if.first.command_opts).to eq({ :cwd => "/tmp" })
       resource.run_action(:purr)
     end
 
@@ -656,7 +656,7 @@ describe Chef::Resource do
 
     it "runs not_if as a block when it is a ruby block" do
       expect_any_instance_of(Chef::Resource::Conditional).to receive(:evaluate_block).at_least(1).times
-      resource.not_if { puts 'foo' }
+      resource.not_if { puts "foo" }
       resource.run_action(:purr)
     end
 
@@ -667,14 +667,14 @@ describe Chef::Resource do
     end
 
     it "accepts command options for not_if conditionals" do
-      resource.not_if("pwd" , :cwd => '/tmp')
-      expect(resource.not_if.first.command_opts).to eq({:cwd => '/tmp'})
+      resource.not_if("pwd" , :cwd => "/tmp")
+      expect(resource.not_if.first.command_opts).to eq({ :cwd => "/tmp" })
     end
 
     it "accepts multiple not_if conditionals" do
       snitch_var1, snitch_var2 = true, true
-      resource.not_if {snitch_var1 = nil}
-      resource.not_if {snitch_var2 = false}
+      resource.not_if { snitch_var1 = nil }
+      resource.not_if { snitch_var2 = false }
       resource.run_action(:purr)
       expect(snitch_var1).to be_nil
       expect(snitch_var2).to be_falsey
@@ -698,7 +698,7 @@ describe Chef::Resource do
       end
 
       it "should raise Chef::Exceptions::ValidationFailed on an attempt to set the guard_interpreter attribute to something other than a Symbol" do
-        expect { resource.guard_interpreter('command_dot_com') }.to raise_error(Chef::Exceptions::ValidationFailed)
+        expect { resource.guard_interpreter("command_dot_com") }.to raise_error(Chef::Exceptions::ValidationFailed)
       end
 
       it "should not raise an exception when setting the guard interpreter attribute to a Symbol" do
@@ -743,6 +743,12 @@ describe Chef::Resource do
       expect(resource.should_skip?(:purr)).to be_truthy
     end
 
+    it "should return false when only_if is met and also not_if is not met" do
+      resource.only_if { true }
+      resource.not_if { false }
+      expect(resource.should_skip?(:purr)).to be_falsey
+    end
+
     it "should return true when one of multiple only_if's is not met" do
       resource.only_if { true }
       resource.only_if { false }
@@ -757,6 +763,20 @@ describe Chef::Resource do
       expect(resource.should_skip?(:purr)).to be_truthy
     end
 
+    it "should return false when all of multiple only_if's are met" do
+      resource.only_if { true }
+      resource.only_if { true }
+      resource.only_if { true }
+      expect(resource.should_skip?(:purr)).to be_falsey
+    end
+
+    it "should return false when all of multiple not_if's are not met" do
+      resource.not_if { false }
+      resource.not_if { false }
+      resource.not_if { false }
+      expect(resource.should_skip?(:purr)).to be_falsey
+    end
+
     it "should return true when action is :nothing" do
       expect(resource.should_skip?(:nothing)).to be_truthy
     end
@@ -784,7 +804,7 @@ describe Chef::Resource do
     }
     before do
       node.automatic_attrs[:platform] = "fubuntu"
-      node.automatic_attrs[:platform_version] = '10.04'
+      node.automatic_attrs[:platform_version] = "10.04"
     end
 
     it "should not run only_if/not_if conditionals (CHEF-972)" do
@@ -800,7 +820,7 @@ describe Chef::Resource do
       runner = Chef::Runner.new(run_context)
       Chef::Platform.set(
         :resource => :cat,
-        :provider => Chef::Provider::SnakeOil
+        :provider => Chef::Provider::SnakeOil,
       )
 
       resource1.only_if { snitch_var1 = 1 }
@@ -830,21 +850,21 @@ describe Chef::Resource do
       Chef::Resource.send(:remove_const, :Klz)
     end
 
-    it 'adds mappings for a single platform' do
+    it "adds mappings for a single platform" do
       expect(Chef.resource_handler_map).to receive(:set).with(
-        :dinobot, Chef::Resource::Klz, { platform: ['autobots'] }
+        :dinobot, Chef::Resource::Klz, { platform: ["autobots"] }
       )
-      klz.provides :dinobot, platform: ['autobots']
+      klz.provides :dinobot, platform: ["autobots"]
     end
 
-    it 'adds mappings for multiple platforms' do
+    it "adds mappings for multiple platforms" do
       expect(Chef.resource_handler_map).to receive(:set).with(
-        :energy, Chef::Resource::Klz, { platform: ['autobots', 'decepticons']}
+        :energy, Chef::Resource::Klz, { platform: ["autobots", "decepticons"] }
       )
-      klz.provides :energy, platform: ['autobots', 'decepticons']
+      klz.provides :energy, platform: ["autobots", "decepticons"]
     end
 
-    it 'adds mappings for all platforms' do
+    it "adds mappings for all platforms" do
       expect(Chef.resource_handler_map).to receive(:set).with(
         :tape_deck, Chef::Resource::Klz, {}
       )
@@ -863,7 +883,7 @@ describe Chef::Resource do
         node.name("bumblebee")
         node.automatic[:platform] = "autobots"
         node.automatic[:platform_version] = "6.1"
-        Object.const_set('Soundwave', klz1)
+        Object.const_set("Soundwave", klz1)
         klz1.provides :soundwave
       end
 
@@ -885,8 +905,8 @@ describe Chef::Resource do
         node.name("bumblebee")
         node.automatic[:platform] = "autobots"
         node.automatic[:platform_version] = "6.1"
-        klz2.provides :dinobot, :platform => ['autobots']
-        Object.const_set('Grimlock', klz2)
+        klz2.provides :dinobot, :platform => ["autobots"]
+        Object.const_set("Grimlock", klz2)
         klz2.provides :grimlock
       end
 
@@ -980,15 +1000,15 @@ describe Chef::Resource do
 
     it "when set to false should show compiled resource for failed resource" do
       expect { resource_file.run_action(action) }.to raise_error { |err|
-            expect(compiled_resource_data(resource_file, action, err)).to match 'path "/nonexistent/CHEF-5098/file"'
-          }
+        expect(compiled_resource_data(resource_file, action, err)).to match 'path "/nonexistent/CHEF-5098/file"'
+      }
     end
 
     it "when set to true should show compiled resource for failed resource" do
       resource_file.sensitive true
       expect { resource_file.run_action(action) }.to raise_error { |err|
-            expect(compiled_resource_data(resource_file, action, err)).to eql("suppressed sensitive resource output")
-          }
+        expect(compiled_resource_data(resource_file, action, err)).to eql("suppressed sensitive resource output")
+      }
     end
 
   end
@@ -999,7 +1019,7 @@ describe Chef::Resource do
         allowed_actions(%i{one two})
       end
     end
-    let(:resource) { resource_class.new('test', nil) }
+    let(:resource) { resource_class.new("test", nil) }
     subject { resource.action }
 
     context "with a no action" do
@@ -1021,7 +1041,7 @@ describe Chef::Resource do
     end
 
     context "with a string action" do
-      before { resource.action('two') }
+      before { resource.action("two") }
       it { is_expected.to eq [:two] }
     end
 
@@ -1050,7 +1070,7 @@ describe Chef::Resource do
   end
 
   describe ".default_action" do
-    let(:default_action) { }
+    let(:default_action) {}
     let(:resource_class) do
       actions = default_action
       Class.new(described_class) do
@@ -1069,7 +1089,7 @@ describe Chef::Resource do
     end
 
     context "with a string default action" do
-      let(:default_action) { 'one' }
+      let(:default_action) { "one" }
       it { is_expected.to eq [:one] }
     end
 

data/spec/unit/rest/auth_credentials_spec.rb

@@ -1,9 +1,9 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Brown (<cb@opscode.com>)
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Brown (<cb@chef.io>)
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,44 +19,13 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'uri'
-require 'net/https'
-
-KEY_DOT_PEM=<<-END_RSA_KEY
------BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEA49TA0y81ps0zxkOpmf5V4/c4IeR5yVyQFpX3JpxO4TquwnRh
-8VSUhrw8kkTLmB3cS39Db+3HadvhoqCEbqPE6915kXSuk/cWIcNozujLK7tkuPEy
-YVsyTioQAddSdfe+8EhQVf3oHxaKmUd6waXrWqYCnhxgOjxocenREYNhZ/OETIei
-PbOku47vB4nJK/0GhKBytL2XnsRgfKgDxf42BqAi1jglIdeq8lAWZNF9TbNBU21A
-O1iuT7Pm6LyQujhggPznR5FJhXKRUARXBJZawxpGV4dGtdcahwXNE4601aXPra+x
-PcRd2puCNoEDBzgVuTSsLYeKBDMSfs173W1QYwIDAQABAoIBAGF05q7vqOGbMaSD
-2Q7YbuE/JTHKTBZIlBI1QC2x+0P5GDxyEFttNMOVzcs7xmNhkpRw8eX1LrInrpMk
-WsIBKAFFEfWYlf0RWtRChJjNl+szE9jQxB5FJnWtJH/FHa78tR6PsF24aQyzVcJP
-g0FGujBihwgfV0JSCNOBkz8MliQihjQA2i8PGGmo4R4RVzGfxYKTIq9vvRq/+QEa
-Q4lpVLoBqnENpnY/9PTl6JMMjW2b0spbLjOPVwDaIzXJ0dChjNXo15K5SHI5mALJ
-I5gN7ODGb8PKUf4619ez194FXq+eob5YJdilTFKensIUvt3YhP1ilGMM+Chi5Vi/
-/RCTw3ECgYEA9jTw4wv9pCswZ9wbzTaBj9yZS3YXspGg26y6Ohq3ZmvHz4jlT6uR
-xK+DDcUiK4072gci8S4Np0fIVS7q6ivqcOdzXPrTF5/j+MufS32UrBbUTPiM1yoO
-ECcy+1szl/KoLEV09bghPbvC58PFSXV71evkaTETYnA/F6RK12lEepcCgYEA7OSy
-bsMrGDVU/MKJtwqyGP9ubA53BorM4Pp9VVVSCrGGVhb9G/XNsjO5wJC8J30QAo4A
-s59ZzCpyNRy046AB8jwRQuSwEQbejSdeNgQGXhZ7aIVUtuDeFFdaIz/zjVgxsfj4
-DPOuzieMmJ2MLR4F71ocboxNoDI7xruPSE8dDhUCgYA3vx732cQxgtHwAkeNPJUz
-dLiE/JU7CnxIoSB9fYUfPLI+THnXgzp7NV5QJN2qzMzLfigsQcg3oyo6F2h7Yzwv
-GkjlualIRRzCPaCw4Btkp7qkPvbs1QngIHALt8fD1N69P3DPHkTwjG4COjKWgnJq
-qoHKS6Fe/ZlbigikI6KsuwKBgQCTlSLoyGRHr6oj0hqz01EDK9ciMJzMkZp0Kvn8
-OKxlBxYW+jlzut4MQBdgNYtS2qInxUoAnaz2+hauqhSzntK3k955GznpUatCqx0R
-b857vWviwPX2/P6+E3GPdl8IVsKXCvGWOBZWTuNTjQtwbDzsUepWoMgXnlQJSn5I
-YSlLxQKBgQD16Gw9kajpKlzsPa6XoQeGmZALT6aKWJQlrKtUQIrsIWM0Z6eFtX12
-2jjHZ0awuCQ4ldqwl8IfRogWMBkHOXjTPVK0YKWWlxMpD/5+bGPARa5fir8O1Zpo
-Y6S6MeZ69Rp89ma4ttMZ+kwi1+XyHqC/dlcVRW42Zl5Dc7BALRlJjQ==
------END RSA PRIVATE KEY-----
-  END_RSA_KEY
-
+require "spec_helper"
+require "uri"
+require "net/https"
 
 describe Chef::REST::AuthCredentials do
   before do
-    @key_file_fixture = CHEF_SPEC_DATA + '/ssl/private_key.pem'
+    @key_file_fixture = CHEF_SPEC_DATA + "/ssl/private_key.pem"
     @key = OpenSSL::PKey::RSA.new(IO.read(@key_file_fixture).strip)
     @auth_credentials = Chef::REST::AuthCredentials.new("client-name", @key)
   end
@@ -67,52 +36,51 @@ describe Chef::REST::AuthCredentials do
 
   it "loads the private key when initialized with the path to the key" do
     expect(@auth_credentials.key).to respond_to(:private_encrypt)
-    expect(@auth_credentials.key.to_s).to eq(KEY_DOT_PEM)
+    expect(@auth_credentials.key).to eq(@key)
   end
 
   describe "when loading the private key" do
     it "strips extra whitespace before checking the key" do
-      key_file_fixture = CHEF_SPEC_DATA + '/ssl/private_key_with_whitespace.pem'
-      expect {Chef::REST::AuthCredentials.new("client-name", @key_file_fixture)}.not_to raise_error
+      key_file_fixture = CHEF_SPEC_DATA + "/ssl/private_key_with_whitespace.pem"
+      expect { Chef::REST::AuthCredentials.new("client-name", @key_file_fixture) }.not_to raise_error
     end
   end
 
   describe "generating signature headers for a request" do
     before do
       @request_time = Time.at(1270920860)
-      @request_params = {:http_method => :POST, :path => "/clients", :body => '{"some":"json"}', :host => "localhost"}
+      @request_params = { :http_method => :POST, :path => "/clients", :body => '{"some":"json"}', :host => "localhost" }
+      allow(Chef::Config).to(
+        receive(:[]).with(:authentication_protocol_version).and_return(protocol_version))
     end
 
-    it "generates signature headers for the request" do
-      allow(Time).to receive(:now).and_return(@request_time)
-      actual = @auth_credentials.signature_headers(@request_params)
-      expect(actual["HOST"]).to                    eq("localhost")
-      expect(actual["X-OPS-AUTHORIZATION-1"]).to eq("kBssX1ENEwKtNYFrHElN9vYGWS7OeowepN9EsYc9csWfh8oUovryPKDxytQ/")
-      expect(actual["X-OPS-AUTHORIZATION-2"]).to eq("Wc2/nSSyxdWJjjfHzrE+YrqNQTaArOA7JkAf5p75eTUonCWcvNPjFrZVgKGS")
-      expect(actual["X-OPS-AUTHORIZATION-3"]).to eq("yhzHJQh+lcVA9wwARg5Hu9q+ddS8xBOdm3Vp5atl5NGHiP0loiigMYvAvzPO")
-      expect(actual["X-OPS-AUTHORIZATION-4"]).to eq("r9853eIxwYMhn5hLGhAGFQznJbE8+7F/lLU5Zmk2t2MlPY8q3o1Q61YD8QiJ")
-      expect(actual["X-OPS-AUTHORIZATION-5"]).to eq("M8lIt53ckMyUmSU0DDURoiXLVkE9mag/6Yq2tPNzWq2AdFvBqku9h2w+DY5k")
-      expect(actual["X-OPS-AUTHORIZATION-6"]).to eq("qA5Rnzw5rPpp3nrWA9jKkPw4Wq3+4ufO2Xs6w7GCjA==")
-      expect(actual["X-OPS-CONTENT-HASH"]).to eq("1tuzs5XKztM1ANrkGNPah6rW9GY=")
-      expect(actual["X-OPS-SIGN"]).to         match(%r{(version=1\.0)|(algorithm=sha1;version=1.0;)})
-      expect(actual["X-OPS-TIMESTAMP"]).to    eq("2010-04-10T17:34:20Z")
-      expect(actual["X-OPS-USERID"]).to       eq("client-name")
-
-    end
+    context "when configured for version 1.0 of the authn protocol" do
+      let(:protocol_version) { "1.0" }
 
-    describe "when configured for version 1.1 of the authn protocol" do
-      before do
-        Chef::Config[:authentication_protocol_version] = "1.1"
+      it "generates signature headers for the request" do
+        allow(Time).to receive(:now).and_return(@request_time)
+        actual = @auth_credentials.signature_headers(@request_params)
+        expect(actual["HOST"]).to eq("localhost")
+        expect(actual["X-OPS-AUTHORIZATION-1"]).to eq("kBssX1ENEwKtNYFrHElN9vYGWS7OeowepN9EsYc9csWfh8oUovryPKDxytQ/")
+        expect(actual["X-OPS-AUTHORIZATION-2"]).to eq("Wc2/nSSyxdWJjjfHzrE+YrqNQTaArOA7JkAf5p75eTUonCWcvNPjFrZVgKGS")
+        expect(actual["X-OPS-AUTHORIZATION-3"]).to eq("yhzHJQh+lcVA9wwARg5Hu9q+ddS8xBOdm3Vp5atl5NGHiP0loiigMYvAvzPO")
+        expect(actual["X-OPS-AUTHORIZATION-4"]).to eq("r9853eIxwYMhn5hLGhAGFQznJbE8+7F/lLU5Zmk2t2MlPY8q3o1Q61YD8QiJ")
+        expect(actual["X-OPS-AUTHORIZATION-5"]).to eq("M8lIt53ckMyUmSU0DDURoiXLVkE9mag/6Yq2tPNzWq2AdFvBqku9h2w+DY5k")
+        expect(actual["X-OPS-AUTHORIZATION-6"]).to eq("qA5Rnzw5rPpp3nrWA9jKkPw4Wq3+4ufO2Xs6w7GCjA==")
+        expect(actual["X-OPS-CONTENT-HASH"]).to eq("1tuzs5XKztM1ANrkGNPah6rW9GY=")
+        expect(actual["X-OPS-SIGN"]).to         match(%r{(version=1\.0)|(algorithm=sha1;version=1.0;)})
+        expect(actual["X-OPS-TIMESTAMP"]).to    eq("2010-04-10T17:34:20Z")
+        expect(actual["X-OPS-USERID"]).to       eq("client-name")
       end
+    end
 
-      after do
-        Chef::Config[:authentication_protocol_version] = "1.0"
-      end
+    context "when configured for version 1.1 of the authn protocol" do
+      let(:protocol_version) { "1.1" }
 
       it "generates the correct signature for version 1.1" do
         allow(Time).to receive(:now).and_return(@request_time)
         actual = @auth_credentials.signature_headers(@request_params)
-        expect(actual["HOST"]).to                    eq("localhost")
+        expect(actual["HOST"]).to eq("localhost")
         expect(actual["X-OPS-CONTENT-HASH"]).to eq("1tuzs5XKztM1ANrkGNPah6rW9GY=")
         expect(actual["X-OPS-SIGN"]).to         eq("algorithm=sha1;version=1.1;")
         expect(actual["X-OPS-TIMESTAMP"]).to    eq("2010-04-10T17:34:20Z")
@@ -126,17 +94,17 @@ describe Chef::REST::AuthCredentials do
 end
 
 describe Chef::REST::RESTRequest do
-  def new_request(method=nil)
+  def new_request(method = nil)
     method ||= :POST
     Chef::REST::RESTRequest.new(method, @url, @req_body, @headers)
   end
 
   before do
-    @auth_credentials = Chef::REST::AuthCredentials.new("client-name", CHEF_SPEC_DATA + '/ssl/private_key.pem')
+    @auth_credentials = Chef::REST::AuthCredentials.new("client-name", CHEF_SPEC_DATA + "/ssl/private_key.pem")
     @url = URI.parse("http://chef.example.com:4000/?q=chef_is_awesome")
     @req_body = '{"json_data":"as_a_string"}'
-    @headers = { "Content-type" =>"application/json",
-                 "Accept"=>"application/json",
+    @headers = { "Content-type" => "application/json",
+                 "Accept" => "application/json",
                  "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
                  "Host" => "chef.example.com:4000" }
     @request = Chef::REST::RESTRequest.new(:POST, @url, @req_body, @headers)