chef 12.6.0 → 12.7.2

data/spec/functional/resource/reboot_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Chris Doherty <cdoherty@getchef.com>)
-# Copyright:: Copyright (c) 2014 Chef, Inc.
+# Author:: Chris Doherty <cdoherty@chef.io>)
+# Copyright:: Copyright 2014-2016, Chef, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::Resource::Reboot do
 
@@ -24,7 +24,7 @@ describe Chef::Resource::Reboot do
     {
       :delay_mins => 5,
       :requested_by => "reboot resource functional test",
-      :reason => "reboot resource spec test"
+      :reason => "reboot resource spec test",
     }
   end
 
@@ -42,7 +42,7 @@ describe Chef::Resource::Reboot do
     create_resource
   end
 
-  shared_context 'testing run context modification' do
+  shared_context "testing run context modification" do
     def test_reboot_action(resource)
       reboot_info = resource.run_context.reboot_info
       expect(reboot_info.keys.sort).to eq([:delay_mins, :reason, :requested_by, :timestamp])
@@ -55,8 +55,8 @@ describe Chef::Resource::Reboot do
   end
 
   # the currently defined behavior for multiple calls to this resource is "last one wins."
-  describe 'the request_reboot_on_successful_run action' do
-    include_context 'testing run context modification'
+  describe "the request_reboot_on_successful_run action" do
+    include_context "testing run context modification"
 
     before do
       resource.run_action(:request_reboot)
@@ -66,19 +66,19 @@ describe Chef::Resource::Reboot do
       resource.run_context.cancel_reboot
     end
 
-    it 'should have modified the run context correctly' do
+    it "should have modified the run context correctly" do
       test_reboot_action(resource)
     end
   end
 
-  describe 'the reboot_interrupt_run action' do
-    include_context 'testing run context modification'
+  describe "the reboot_interrupt_run action" do
+    include_context "testing run context modification"
 
     after do
       resource.run_context.cancel_reboot
     end
 
-    it 'should have modified the run context correctly' do
+    it "should have modified the run context correctly" do
       # this doesn't actually test the flow of Chef::Client#do_run, unfortunately.
       expect {
         resource.run_action(:reboot_now)
@@ -94,7 +94,7 @@ describe Chef::Resource::Reboot do
       resource.run_action(:cancel)
     end
 
-    it 'should have cleared the reboot request' do
+    it "should have cleared the reboot request" do
       # arguably we shouldn't be querying RunContext's internal data directly.
       expect(resource.run_context.reboot_info).to eq({})
       expect(resource.run_context.reboot_requested?).to be_falsey

data/spec/functional/resource/registry_spec.rb

@@ -1,7 +1,7 @@
 #
-# Author:: Prajakta Purohit (<prajakta@opscode.com>)
-# Author:: Lamont Granquist (<lamont@opscode.com>)
-# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# Author:: Prajakta Purohit (<prajakta@chef.io>)
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright 2011-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -27,15 +27,15 @@ describe Chef::Resource::RegistryKey, :unix_only do
     node = Chef::Node.new
     ohai = Ohai::System.new
     ohai.all_plugins
-    node.consume_external_attrs(ohai.data,{})
+    node.consume_external_attrs(ohai.data, {})
     run_context = Chef::RunContext.new(node, {}, events)
     @resource = Chef::Resource::RegistryKey.new("HKCU\\Software", run_context)
   end
   context "when load_current_resource is run on a non-windows node" do
     it "throws an exception because you don't have a windows registry (derp)" do
       @resource.key("HKCU\\Software\\Opscode")
-      @resource.values([{:name=>"Color", :type=>:string, :data=>"Orange"}])
-      expect{@resource.run_action(:create)}.to raise_error(Chef::Exceptions::Win32NotWindows)
+      @resource.values([{ :name => "Color", :type => :string, :data => "Orange" }])
+      expect { @resource.run_action(:create) }.to raise_error(Chef::Exceptions::Win32NotWindows)
     end
   end
 end
@@ -43,8 +43,8 @@ end
 describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
   # parent and key must be single keys, not paths
-  let(:parent) { 'Opscode' }
-  let(:child) { 'Whatever' }
+  let(:parent) { "Opscode" }
+  let(:child) { "Whatever" }
   let(:key_parent) { "SOFTWARE\\" + parent }
   let(:key_child) { "SOFTWARE\\" + parent + "\\" + child }
   # must be under HKLM\SOFTWARE for WOW64 redirection to work
@@ -98,7 +98,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     @node = Chef::Node.new
     ohai = Ohai::System.new
     ohai.all_plugins
-    @node.consume_external_attrs(ohai.data,{})
+    @node.consume_external_attrs(ohai.data, {})
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
     @new_resource = Chef::Resource::RegistryKey.new(resource_name, @run_context)
@@ -111,10 +111,10 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
   before do
     @node.name("windowsbox")
 
-    @rest_client = double("Chef::REST (mock)")
+    @rest_client = double("Chef::ServerAPI (mock)")
     allow(@rest_client).to receive(:create_url).and_return("reports/nodes/windowsbox/runs/#{@run_id}");
-    allow(@rest_client).to receive(:raw_http_request).and_return({"result"=>"ok"});
-    allow(@rest_client).to receive(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/windowsbox/runs/#{@run_id}"});
+    allow(@rest_client).to receive(:raw_http_request).and_return({ "result" => "ok" });
+    allow(@rest_client).to receive(:post_rest).and_return({ "uri" => "https://example.com/reports/nodes/windowsbox/runs/#{@run_id}" });
 
     @resource_reporter = Chef::ResourceReporter.new(@rest_client)
     @events.register(@resource_reporter)
@@ -122,7 +122,6 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     @resource_reporter.run_started(@run_status)
     @run_id = @resource_reporter.run_id
 
-
     @new_resource.cookbook_name = "monkey"
     @cookbook_version = double("Cookbook::Version", :version => "1.2.3")
     allow(@new_resource).to receive(:cookbook_version).and_return(@cookbook_version)
@@ -138,76 +137,76 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     end
     it "creates registry key, value if the key is missing" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Color", :type=>:string, :data=>"Orange"}])
+      @new_resource.values([{ :name => "Color", :type => :string, :data => "Orange" }])
       @new_resource.run_action(:create)
 
       expect(@registry.key_exists?(reg_child)).to eq(true)
-      expect(@registry.data_exists?(reg_child, {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
     end
 
     it "does not create the key if it already exists with same value, type and data" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Color", :type=>:string, :data=>"Orange"}])
+      @new_resource.values([{ :name => "Color", :type => :string, :data => "Orange" }])
       @new_resource.run_action(:create)
 
       expect(@registry.key_exists?(reg_child)).to eq(true)
-      expect(@registry.data_exists?(reg_child, {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
     end
 
     it "creates a value if it does not exist" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Mango", :type=>:string, :data=>"Yellow"}])
+      @new_resource.values([{ :name => "Mango", :type => :string, :data => "Yellow" }])
       @new_resource.run_action(:create)
 
-      expect(@registry.data_exists?(reg_child, {:name=>"Mango", :type=>:string, :data=>"Yellow"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Mango", :type => :string, :data => "Yellow" })).to eq(true)
     end
 
     it "modifies the data if the key and value exist and type matches" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Color", :type=>:string, :data=>"Not just Orange - OpscodeOrange!"}])
+      @new_resource.values([{ :name => "Color", :type => :string, :data => "Not just Orange - OpscodeOrange!" }])
       @new_resource.run_action(:create)
 
-      expect(@registry.data_exists?(reg_child, {:name=>"Color", :type=>:string, :data=>"Not just Orange - OpscodeOrange!"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Color", :type => :string, :data => "Not just Orange - OpscodeOrange!" })).to eq(true)
     end
 
     it "modifys the type if the key and value exist and the type does not match" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Color", :type=>:multi_string, :data=>["Not just Orange - OpscodeOrange!"]}])
+      @new_resource.values([{ :name => "Color", :type => :multi_string, :data => ["Not just Orange - OpscodeOrange!"] }])
       @new_resource.run_action(:create)
 
-      expect(@registry.data_exists?(reg_child, {:name=>"Color", :type=>:multi_string, :data=>["Not just Orange - OpscodeOrange!"]})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Color", :type => :multi_string, :data => ["Not just Orange - OpscodeOrange!"] })).to eq(true)
     end
 
     it "creates subkey if parent exists" do
       @new_resource.key(reg_child + '\OpscodeTest')
-      @new_resource.values([{:name=>"Chef", :type=>:multi_string, :data=>["OpscodeOrange", "Rules"]}])
+      @new_resource.values([{ :name => "Chef", :type => :multi_string, :data => ["OpscodeOrange", "Rules"] }])
       @new_resource.recursive(false)
       @new_resource.run_action(:create)
 
       expect(@registry.key_exists?(reg_child + '\OpscodeTest')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\OpscodeTest', {:name=>"Chef", :type=>:multi_string, :data=>["OpscodeOrange", "Rules"]})).to eq(true)
+      expect(@registry.value_exists?(reg_child + '\OpscodeTest', { :name => "Chef", :type => :multi_string, :data => ["OpscodeOrange", "Rules"] })).to eq(true)
     end
 
     it "gives error if action create and parent does not exist and recursive is set to false" do
       @new_resource.key(reg_child + '\Missing1\Missing2')
-      @new_resource.values([{:name=>"OC", :type=>:string, :data=>"MissingData"}])
+      @new_resource.values([{ :name => "OC", :type => :string, :data => "MissingData" }])
       @new_resource.recursive(false)
-      expect{@new_resource.run_action(:create)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect { @new_resource.run_action(:create) }.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
     end
 
     it "creates missing keys if action create and parent does not exist and recursive is set to true" do
       @new_resource.key(reg_child + '\Missing1\Missing2')
-      @new_resource.values([{:name=>"OC", :type=>:string, :data=>"MissingData"}])
+      @new_resource.values([{ :name => "OC", :type => :string, :data => "MissingData" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create)
 
       expect(@registry.key_exists?(reg_child + '\Missing1\Missing2')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\Missing1\Missing2', {:name=>"OC", :type=>:string, :data=>"MissingData"})).to eq(true)
+      expect(@registry.value_exists?(reg_child + '\Missing1\Missing2', { :name => "OC", :type => :string, :data => "MissingData" })).to eq(true)
     end
 
     it "creates key with multiple value as specified" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"one", :type=>:string, :data=>"1"},{:name=>"two", :type=>:string, :data=>"2"},{:name=>"three", :type=>:string, :data=>"3"}])
+      @new_resource.values([{ :name => "one", :type => :string, :data => "1" }, { :name => "two", :type => :string, :data => "2" }, { :name => "three", :type => :string, :data => "3" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create)
 
@@ -226,12 +225,12 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
       end
       it "creates a key in a 32-bit registry that is not viewable in 64-bit" do
         @new_resource.key(reg_child + '\Atraxi' )
-        @new_resource.values([{:name=>"OC", :type=>:string, :data=>"Data"}])
+        @new_resource.values([{ :name => "OC", :type => :string, :data => "Data" }])
         @new_resource.recursive(true)
         @new_resource.architecture(:i386)
         @new_resource.run_action(:create)
         @registry.architecture = :i386
-        expect(@registry.data_exists?(reg_child + '\Atraxi', {:name=>"OC", :type=>:string, :data=>"Data"})).to eq(true)
+        expect(@registry.data_exists?(reg_child + '\Atraxi', { :name => "OC", :type => :string, :data => "Data" })).to eq(true)
         @registry.architecture = :x86_64
         expect(@registry.key_exists?(reg_child + '\Atraxi')).to eq(false)
       end
@@ -239,7 +238,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
     it "prepares the reporting data for action :create" do
       @new_resource.key(reg_child + '\Ood')
-      @new_resource.values([{:name=>"ReportingVal1", :type=>:string, :data=>"report1"},{:name=>"ReportingVal2", :type=>:string, :data=>"report2"}])
+      @new_resource.values([{ :name => "ReportingVal1", :type => :string, :data => "report1" }, { :name => "ReportingVal2", :type => :string, :data => "report2" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create)
       @report = @resource_reporter.prepare_run_data
@@ -248,8 +247,8 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
       expect(@report["resources"][0]["id"]).to eq(reg_child + '\Ood')
-      expect(@report["resources"][0]["after"][:values]).to eq([{:name=>"ReportingVal1", :type=>:string, :data=>"report1"},
-                                                           {:name=>"ReportingVal2", :type=>:string, :data=>"report2"}])
+      expect(@report["resources"][0]["after"][:values]).to eq([{ :name => "ReportingVal1", :type => :string, :data => "report1" },
+                                                           { :name => "ReportingVal2", :type => :string, :data => "report2" }])
       expect(@report["resources"][0]["before"][:values]).to eq([])
       expect(@report["resources"][0]["result"]).to eq("create")
       expect(@report["status"]).to eq("success")
@@ -263,7 +262,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not throw an exception if the keys do not exist but recursive is set to false" do
         @new_resource.key(reg_child + '\Slitheen\Raxicoricofallapatorius')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
@@ -271,7 +270,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
       end
       it "does not create key if the action is create" do
         @new_resource.key(reg_child + '\Slitheen')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create)
         expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
@@ -286,61 +285,61 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
     it "creates registry key, value if the key is missing" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Color", :type=>:string, :data=>"Orange"}])
+      @new_resource.values([{ :name => "Color", :type => :string, :data => "Orange" }])
       @new_resource.run_action(:create_if_missing)
 
       expect(@registry.key_exists?(reg_parent)).to eq(true)
       expect(@registry.key_exists?(reg_child)).to eq(true)
-      expect(@registry.data_exists?(reg_child, {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
     end
 
     it "does not create the key if it already exists with same value, type and data" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Color", :type=>:string, :data=>"Orange"}])
+      @new_resource.values([{ :name => "Color", :type => :string, :data => "Orange" }])
       @new_resource.run_action(:create_if_missing)
 
       expect(@registry.key_exists?(reg_child)).to eq(true)
-      expect(@registry.data_exists?(reg_child, {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
     end
 
     it "creates a value if it does not exist" do
       @new_resource.key(reg_child)
-      @new_resource.values([{:name=>"Mango", :type=>:string, :data=>"Yellow"}])
+      @new_resource.values([{ :name => "Mango", :type => :string, :data => "Yellow" }])
       @new_resource.run_action(:create_if_missing)
 
-      expect(@registry.data_exists?(reg_child, {:name=>"Mango", :type=>:string, :data=>"Yellow"})).to eq(true)
+      expect(@registry.data_exists?(reg_child, { :name => "Mango", :type => :string, :data => "Yellow" })).to eq(true)
     end
 
     it "creates subkey if parent exists" do
       @new_resource.key(reg_child + '\Pyrovile')
-      @new_resource.values([{:name=>"Chef", :type=>:multi_string, :data=>["OpscodeOrange", "Rules"]}])
+      @new_resource.values([{ :name => "Chef", :type => :multi_string, :data => ["OpscodeOrange", "Rules"] }])
       @new_resource.recursive(false)
       @new_resource.run_action(:create_if_missing)
 
       expect(@registry.key_exists?(reg_child + '\Pyrovile')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\Pyrovile', {:name=>"Chef", :type=>:multi_string, :data=>["OpscodeOrange", "Rules"]})).to eq(true)
+      expect(@registry.value_exists?(reg_child + '\Pyrovile', { :name => "Chef", :type => :multi_string, :data => ["OpscodeOrange", "Rules"] })).to eq(true)
     end
 
     it "gives error if action create and parent does not exist and recursive is set to false" do
       @new_resource.key(reg_child + '\Sontaran\Sontar')
-      @new_resource.values([{:name=>"OC", :type=>:string, :data=>"MissingData"}])
+      @new_resource.values([{ :name => "OC", :type => :string, :data => "MissingData" }])
       @new_resource.recursive(false)
-      expect{@new_resource.run_action(:create_if_missing)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect { @new_resource.run_action(:create_if_missing) }.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
     end
 
     it "creates missing keys if action create and parent does not exist and recursive is set to true" do
       @new_resource.key(reg_child + '\Sontaran\Sontar')
-      @new_resource.values([{:name=>"OC", :type=>:string, :data=>"MissingData"}])
+      @new_resource.values([{ :name => "OC", :type => :string, :data => "MissingData" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create_if_missing)
 
       expect(@registry.key_exists?(reg_child + '\Sontaran\Sontar')).to eq(true)
-      expect(@registry.value_exists?(reg_child + '\Sontaran\Sontar', {:name=>"OC", :type=>:string, :data=>"MissingData"})).to eq(true)
+      expect(@registry.value_exists?(reg_child + '\Sontaran\Sontar', { :name => "OC", :type => :string, :data => "MissingData" })).to eq(true)
     end
 
     it "creates key with multiple value as specified" do
       @new_resource.key(reg_child + '\Adipose')
-      @new_resource.values([{:name=>"one", :type=>:string, :data=>"1"},{:name=>"two", :type=>:string, :data=>"2"},{:name=>"three", :type=>:string, :data=>"3"}])
+      @new_resource.values([{ :name => "one", :type => :string, :data => "1" }, { :name => "two", :type => :string, :data => "2" }, { :name => "three", :type => :string, :data => "3" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create_if_missing)
 
@@ -351,7 +350,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
     it "prepares the reporting data for :create_if_missing" do
       @new_resource.key(reg_child + '\Judoon')
-      @new_resource.values([{:name=>"ReportingVal3", :type=>:string, :data=>"report3"}])
+      @new_resource.values([{ :name => "ReportingVal3", :type => :string, :data => "report3" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:create_if_missing)
       @report = @resource_reporter.prepare_run_data
@@ -360,7 +359,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
       expect(@report["resources"][0]["id"]).to eq(reg_child + '\Judoon')
-      expect(@report["resources"][0]["after"][:values]).to eq([{:name=>"ReportingVal3", :type=>:string, :data=>"report3"}])
+      expect(@report["resources"][0]["after"][:values]).to eq([{ :name => "ReportingVal3", :type => :string, :data => "report3" }])
       expect(@report["resources"][0]["before"][:values]).to eq([])
       expect(@report["resources"][0]["result"]).to eq("create_if_missing")
       expect(@report["status"]).to eq("success")
@@ -374,7 +373,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not throw an exception if the keys do not exist but recursive is set to false" do
         @new_resource.key(reg_child + '\Zygons\Zygor')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create_if_missing) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
@@ -382,7 +381,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
       end
       it "does nothing if the action is create_if_missing" do
         @new_resource.key(reg_child + '\Zygons')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:create_if_missing)
         expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
@@ -399,7 +398,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     it "takes no action if the specified key path does not exist in the system" do
       expect(@registry.key_exists?(reg_parent + '\Osirian')).to eq(false)
 
-      @new_resource.key(reg_parent+ '\Osirian')
+      @new_resource.key(reg_parent + '\Osirian')
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
@@ -407,53 +406,53 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     end
 
     it "takes no action if the key exists but the value does not" do
-      expect(@registry.data_exists?(reg_parent + '\Opscode', {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
+      expect(@registry.data_exists?(reg_parent + '\Opscode', { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
 
       @new_resource.key(reg_parent + '\Opscode')
-      @new_resource.values([{:name=>"LooksLike", :type=>:multi_string, :data=>["SeattleGrey", "OCOrange"]}])
+      @new_resource.values([{ :name => "LooksLike", :type => :multi_string, :data => ["SeattleGrey", "OCOrange"] }])
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.data_exists?(reg_parent + '\Opscode', {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
+      expect(@registry.data_exists?(reg_parent + '\Opscode', { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
     end
 
     it "deletes only specified values under a key path" do
       @new_resource.key(reg_parent + '\Opscode')
-      @new_resource.values([{:name=>"Opscode", :type=>:multi_string, :data=>["Seattle", "Washington"]}, {:name=>"AKA", :type=>:string, :data=>"OC"}])
+      @new_resource.values([{ :name => "Opscode", :type => :multi_string, :data => ["Seattle", "Washington"] }, { :name => "AKA", :type => :string, :data => "OC" }])
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.data_exists?(reg_parent + '\Opscode', {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(true)
-      expect(@registry.value_exists?(reg_parent + '\Opscode', {:name=>"AKA", :type=>:string, :data=>"OC"})).to eq(false)
-      expect(@registry.value_exists?(reg_parent + '\Opscode', {:name=>"Opscode", :type=>:multi_string, :data=>["Seattle", "Washington"]})).to eq(false)
+      expect(@registry.data_exists?(reg_parent + '\Opscode', { :name => "Color", :type => :string, :data => "Orange" })).to eq(true)
+      expect(@registry.value_exists?(reg_parent + '\Opscode', { :name => "AKA", :type => :string, :data => "OC" })).to eq(false)
+      expect(@registry.value_exists?(reg_parent + '\Opscode', { :name => "Opscode", :type => :multi_string, :data => ["Seattle", "Washington"] })).to eq(false)
     end
 
     it "it deletes the values with the same name irrespective of it type and data" do
       @new_resource.key(reg_parent + '\Opscode')
-      @new_resource.values([{:name=>"Color", :type=>:multi_string, :data=>["Black", "Orange"]}])
+      @new_resource.values([{ :name => "Color", :type => :multi_string, :data => ["Black", "Orange"] }])
       @new_resource.recursive(false)
       @new_resource.run_action(:delete)
 
-      expect(@registry.value_exists?(reg_parent + '\Opscode', {:name=>"Color", :type=>:string, :data=>"Orange"})).to eq(false)
+      expect(@registry.value_exists?(reg_parent + '\Opscode', { :name => "Color", :type => :string, :data => "Orange" })).to eq(false)
     end
 
     it "prepares the reporting data for action :delete" do
       @new_resource.key(reg_parent + '\ReportKey')
-      @new_resource.values([{:name=>"ReportVal4", :type=>:string, :data=>"report4"},{:name=>"ReportVal5", :type=>:string, :data=>"report5"}])
+      @new_resource.values([{ :name => "ReportVal4", :type => :string, :data => "report4" }, { :name => "ReportVal5", :type => :string, :data => "report5" }])
       @new_resource.recursive(true)
       @new_resource.run_action(:delete)
 
       @report = @resource_reporter.prepare_run_data
 
-      expect(@registry.value_exists?(reg_parent + '\ReportKey', [{:name=>"ReportVal4", :type=>:string, :data=>"report4"},{:name=>"ReportVal5", :type=>:string, :data=>"report5"}])).to eq(false)
+      expect(@registry.value_exists?(reg_parent + '\ReportKey', [{ :name => "ReportVal4", :type => :string, :data => "report4" }, { :name => "ReportVal5", :type => :string, :data => "report5" }])).to eq(false)
 
       expect(@report["action"]).to eq("end")
       expect(@report["resources"].count).to eq(1)
       expect(@report["resources"][0]["type"]).to eq("registry_key")
       expect(@report["resources"][0]["name"]).to eq(resource_name)
       expect(@report["resources"][0]["id"]).to eq(reg_parent + '\ReportKey')
-      expect(@report["resources"][0]["before"][:values]).to eq([{:name=>"ReportVal4", :type=>:string, :data=>"report4"},
-                                                            {:name=>"ReportVal5", :type=>:string, :data=>"report5"}])
+      expect(@report["resources"][0]["before"][:values]).to eq([{ :name => "ReportVal4", :type => :string, :data => "report4" },
+                                                            { :name => "ReportVal5", :type => :string, :data => "report5" }])
       #Not testing for after values to match since after -> new_resource values.
       expect(@report["resources"][0]["result"]).to eq("delete")
       expect(@report["status"]).to eq("success")
@@ -466,7 +465,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
       end
       it "does nothing if the action is delete" do
         @new_resource.key(reg_parent + '\OpscodeWhyRun')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:delete)
 
@@ -502,7 +501,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     it "raises an exception if the key has subkeys and recursive == false" do
       @new_resource.key(reg_parent)
       @new_resource.recursive(false)
-      expect{@new_resource.run_action(:delete_key)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+      expect { @new_resource.run_action(:delete_key) }.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
     end
 
     it "ignores the values under a key" do
@@ -544,13 +543,13 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not throw an exception if the key has subkeys but recursive is set to false" do
         @new_resource.key(reg_parent + '\OpscodeWhyRun')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:delete_key)
       end
       it "does nothing if the action is delete_key" do
         @new_resource.key(reg_parent + '\OpscodeWhyRun')
-        @new_resource.values([{:name=>"BriskWalk",:type=>:string,:data=>"is good for health"}])
+        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "is good for health" }])
         @new_resource.recursive(false)
         @new_resource.run_action(:delete_key)