chef 14.2.0 → 14.3.37

data/spec/functional/resource/execute_spec.rb

@@ -106,7 +106,7 @@ describe Chef::Resource::Execute do
 
     it "guard adds additional values in its :environment and runs" do
       resource.only_if %{ruby -e 'exit 1 if ENV["SGCE_SECRET"] != "regularsecret"'}, {
-        :environment => { "SGCE_SECRET" => "regularsecret" },
+        environment: { "SGCE_SECRET" => "regularsecret" },
       }
       resource.run_action(:run)
       expect(resource).to be_updated_by_last_action
@@ -114,7 +114,7 @@ describe Chef::Resource::Execute do
 
     it "guard adds additional values in its :environment and does not run" do
       resource.only_if %{ruby -e 'exit 1 if ENV["SGCE_SECRET"] == "regularsecret"'}, {
-        :environment => { "SGCE_SECRET" => "regularsecret" },
+        environment: { "SGCE_SECRET" => "regularsecret" },
       }
       resource.run_action(:run)
       expect(resource).not_to be_updated_by_last_action
@@ -122,7 +122,7 @@ describe Chef::Resource::Execute do
 
     it "guard overwrites value with its :environment and runs" do
       resource.only_if %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] != "regularsecret"'}, {
-        :environment => { "SAWS_SECRET" => "regularsecret" },
+        environment: { "SAWS_SECRET" => "regularsecret" },
       }
       resource.run_action(:run)
       expect(resource).to be_updated_by_last_action
@@ -130,7 +130,7 @@ describe Chef::Resource::Execute do
 
     it "guard overwrites value with its :environment and does not runs" do
       resource.only_if %{ruby -e 'exit 1 if ENV["SAWS_SECRET"] == "regularsecret"'}, {
-        :environment => { "SAWS_SECRET" => "regularsecret" },
+        environment: { "SAWS_SECRET" => "regularsecret" },
       }
       resource.run_action(:run)
       expect(resource).not_to be_updated_by_last_action

data/spec/functional/resource/file_spec.rb

@@ -51,7 +51,7 @@ describe Chef::Resource::File do
   end
 
   let(:resource_with_relative_path) do
-    create_resource(:use_relative_path => true)
+    create_resource(use_relative_path: true)
   end
 
   let(:unmanaged_content) do

data/spec/functional/resource/git_spec.rb

@@ -22,7 +22,7 @@ require "tmpdir"
 require "shellwords"
 
 # Deploy relies heavily on symlinks, so it doesn't work on windows.
-describe Chef::Resource::Git, :requires_git => true do
+describe Chef::Resource::Git, requires_git: true do
   include Chef::Mixin::ShellOut
   let(:file_cache_path) { Dir.mktmpdir }
   # Some versions of git complains when the deploy directory is
@@ -65,17 +65,17 @@ describe Chef::Resource::Git, :requires_git => true do
   let(:rev_head) { "d294fbfd05aa7709ad9a9b8ef6343b17d355bf5f" }
 
   let(:git_user_config) do
-    <<-E
-[user]
-  name = frodoTbaggins
-  email = frodo@shire.org
+    <<~E
+      [user]
+        name = frodoTbaggins
+        email = frodo@shire.org
 E
   end
 
   before(:each) do
     Chef::Log.level = :warn # silence git command live streams
     @old_file_cache_path = Chef::Config[:file_cache_path]
-    shell_out!("git clone \"#{git_bundle_repo}\" example", :cwd => origin_repo_dir)
+    shell_out!("git clone \"#{git_bundle_repo}\" example", cwd: origin_repo_dir)
     File.open("#{origin_repo}/.git/config", "a+") { |f| f.print(git_user_config) }
     Chef::Config[:file_cache_path] = file_cache_path
   end
@@ -127,10 +127,10 @@ E
 
     it "checks out the revision pointed to by the tag commit, not the tag commit itself" do
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(v1_commit)
       # also verify the tag commit itself is what we expect as an extra sanity check
-      rev = shell_out!("git rev-parse v1.0.0", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      rev = shell_out!("git rev-parse v1.0.0", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(rev).to eq(v1_tag)
     end
 
@@ -138,7 +138,7 @@ E
       # this used to fail because we didn't resolve the annotated tag
       # properly to the pointed to commit.
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(v1_commit)
 
       copy_git_resource.run_action(:sync)
@@ -164,14 +164,14 @@ E
     it "checks out the expected revision ed18" do
       basic_git_resource.revision rev_foo
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_foo)
     end
 
     it "doesn't update if up-to-date" do
       basic_git_resource.revision rev_foo
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_foo)
 
       copy_git_resource.revision rev_foo
@@ -182,7 +182,7 @@ E
     it "checks out the expected revision 972d" do
       basic_git_resource.revision rev_testing
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_testing)
     end
   end
@@ -197,7 +197,7 @@ E
 
     it "checks out the expected revision" do
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_head)
     end
   end
@@ -212,7 +212,7 @@ E
 
     it "checks out HEAD as the default revision" do
       basic_git_resource.run_action(:sync)
-      head_rev = shell_out!("git rev-parse HEAD", :cwd => deploy_directory, :returns => [0]).stdout.strip
+      head_rev = shell_out!("git rev-parse HEAD", cwd: deploy_directory, returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_head)
     end
   end
@@ -220,7 +220,7 @@ E
   context "when dealing with a repo with a degenerate tag named 'HEAD'" do
     before do
       shell_out!("git tag -m\"degenerate tag\" HEAD ed181b3419b6f489bedab282348162a110d6d3a1",
-                 :cwd => origin_repo)
+                 cwd: origin_repo)
     end
 
     let(:basic_git_resource) do
@@ -240,16 +240,16 @@ E
     it "checks out the (master) HEAD revision and ignores the tag" do
       basic_git_resource.run_action(:sync)
       head_rev = shell_out!("git rev-parse HEAD",
-                            :cwd => deploy_directory,
-                            :returns => [0]).stdout.strip
+                            cwd: deploy_directory,
+                            returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_head)
     end
 
     it "checks out the (master) HEAD revision when no revision is specified (ignores tag)" do
       git_resource_default_rev.run_action(:sync)
       head_rev = shell_out!("git rev-parse HEAD",
-                            :cwd => deploy_directory,
-                            :returns => [0]).stdout.strip
+                            cwd: deploy_directory,
+                            returns: [0]).stdout.strip
       expect(head_rev).to eq(rev_head)
     end
 

data/spec/functional/resource/ifconfig_spec.rb

@@ -23,7 +23,7 @@ require "chef/mixin/shell_out"
 # run this test only for following platforms.
 include_flag = !(%w{amazon debian aix}.include?(ohai[:platform_family]) || (ohai[:platform_family] == "rhel" && ohai[:platform_version].to_i < 7))
 
-describe Chef::Resource::Ifconfig, :requires_root, :skip_travis, :external => include_flag do
+describe Chef::Resource::Ifconfig, :requires_root, :skip_travis, external: include_flag do
   # This test does not work in travis because there is no eth0
 
   include Chef::Mixin::ShellOut
@@ -122,7 +122,7 @@ describe Chef::Resource::Ifconfig, :requires_root, :skip_travis, :external => in
   end
 
   exclude_test = ohai[:platform] != "ubuntu"
-  describe "#action_add", :external => exclude_test do
+  describe "#action_add", external: exclude_test do
     after do
       new_resource.run_action(:delete)
     end
@@ -134,7 +134,7 @@ describe Chef::Resource::Ifconfig, :requires_root, :skip_travis, :external => in
     end
   end
 
-  describe "#action_enable", :external => exclude_test do
+  describe "#action_enable", external: exclude_test do
     after do
       new_resource.run_action(:disable)
     end
@@ -145,7 +145,7 @@ describe Chef::Resource::Ifconfig, :requires_root, :skip_travis, :external => in
     end
   end
 
-  describe "#action_disable", :external => exclude_test do
+  describe "#action_disable", external: exclude_test do
     before do
       setup_enable_interface(new_resource)
       new_resource.run_action(:enable)
@@ -157,7 +157,7 @@ describe Chef::Resource::Ifconfig, :requires_root, :skip_travis, :external => in
     end
   end
 
-  describe "#action_delete", :external => exclude_test do
+  describe "#action_delete", external: exclude_test do
     before do
       setup_add_interface(new_resource)
       new_resource.run_action(:add)

data/spec/functional/resource/link_spec.rb

@@ -19,7 +19,7 @@
 require "spec_helper"
 
 if windows?
-  require "chef/win32/file" #probably need this in spec_helper
+  require "chef/win32/file" # probably need this in spec_helper
   require "chef/win32/security"
 end
 

data/spec/functional/resource/mount_spec.rb

@@ -24,7 +24,7 @@ require "tmpdir"
 # run this test only for following platforms.
 include_flag = !(%w{debian rhel amazon aix solaris2}.include?(ohai[:platform_family]))
 
-describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => include_flag do
+describe Chef::Resource::Mount, :requires_root, :skip_travis, external: include_flag do
   # Disabled in travis because it refuses to let us mount a ramdisk. /dev/ramX does not
   # exist even after loading the kernel module
 
@@ -161,7 +161,7 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
   # don't run the remount tests on solaris2 (tmpfs does not support remount)
   # Need to make sure the platforms we've already excluded are considered:
   skip_remount = include_flag || (ohai[:platform] == "solaris2")
-  describe "when the filesystem should be remounted and the resource supports remounting", :external => skip_remount do
+  describe "when the filesystem should be remounted and the resource supports remounting", external: skip_remount do
     it "should remount the filesystem if it is mounted" do
       new_resource.run_action(:mount)
       mount_should_exist(new_resource.mount_point, new_resource.device)

data/spec/functional/resource/powershell_script_spec.rb

@@ -255,16 +255,16 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
 
     context "when dsc is supported", :windows_powershell_dsc_only do
       it "can execute LCM configuration code" do
-        resource.code <<-EOF
-configuration LCM
-{
-  param ($thumbprint)
-  localconfigurationmanager
-  {
-    RebootNodeIfNeeded = $false
-    ConfigurationMode = 'ApplyOnly'
-  }
-}
+        resource.code <<~EOF
+          configuration LCM
+          {
+            param ($thumbprint)
+            localconfigurationmanager
+            {
+              RebootNodeIfNeeded = $false
+              ConfigurationMode = 'ApplyOnly'
+            }
+          }
         EOF
         expect { resource.run_action(:run) }.not_to raise_error
       end
@@ -474,13 +474,13 @@ configuration LCM
 
       it "evaluates a not_if block using the cwd guard parameter" do
         custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
-        resource.not_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", :cwd => custom_cwd
+        resource.not_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", cwd: custom_cwd
         expect(resource.should_skip?(:run)).to be_truthy
       end
 
       it "evaluates an only_if block using the cwd guard parameter" do
         custom_cwd = "#{ENV['SystemRoot']}\\system32\\drivers\\etc"
-        resource.only_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", :cwd => custom_cwd
+        resource.only_if "exit ! [int32]($pwd.path -eq '#{custom_cwd}')", cwd: custom_cwd
         expect(resource.should_skip?(:run)).to be_falsey
       end
 
@@ -581,7 +581,7 @@ configuration LCM
       end
 
       it "raises an error when a 32-bit guard is used on Windows Nano Server", :windows_nano_only do
-        resource.only_if "$true", :architecture => :i386
+        resource.only_if "$true", architecture: :i386
         expect { resource.run_action(:run) }.to raise_error(
           Chef::Exceptions::Win32ArchitectureIncorrect,
           /cannot execute script with requested architecture 'i386' on Windows Nano Server/)

data/spec/functional/resource/reboot_spec.rb

@@ -22,9 +22,9 @@ describe Chef::Resource::Reboot do
 
   let(:expected) do
     {
-      :delay_mins => 5,
-      :requested_by => "reboot resource functional test",
-      :reason => "reboot resource spec test",
+      delay_mins: 5,
+      requested_by: "reboot resource functional test",
+      reason: "reboot resource spec test",
     }
   end
 

data/spec/functional/resource/registry_spec.rb

@@ -34,13 +34,13 @@ describe Chef::Resource::RegistryKey, :unix_only do
   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" }])
+      @resource.values([{ name: "Color", type: :string, data: "Orange" }])
       expect { @resource.run_action(:create) }.to raise_error(Chef::Exceptions::Win32NotWindows)
     end
   end
 end
 
-describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
+describe Chef::Resource::RegistryKey, :windows_only, broken: true do
 
   # parent and key must be single keys, not paths
   let(:parent) { "Opscode" }
@@ -107,7 +107,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     reset_registry
   end
 
-  #Reporting setup
+  # Reporting setup
   before do
     @node.name("windowsbox")
 
@@ -123,7 +123,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
     @run_id = @resource_reporter.run_id
 
     @new_resource.cookbook_name = "monkey"
-    @cookbook_version = double("Cookbook::Version", :version => "1.2.3")
+    @cookbook_version = double("Cookbook::Version", version: "1.2.3")
     @new_resource.cookbook_version(@cookbook_version)
   end
 
@@ -137,110 +137,110 @@ 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 "does not create the key if it already exists with same value and type but datatype of data differs" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "number", :type => :dword, :data => "12345" }])
+      @new_resource.values([{ name: "number", type: :dword, data: "12345" }])
       @new_resource.run_action(:create)
 
       expect(@new_resource).not_to be_updated_by_last_action
       expect(@registry.key_exists?(reg_child)).to eq(true)
-      expect(@registry.data_exists?(reg_child, { :name => "number", :type => :dword, :data => 12344 })).to eq(true)
+      expect(@registry.data_exists?(reg_child, { name: "number", type: :dword, data: 12344 })).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 => %w{OpscodeOrange Rules} }])
+      @new_resource.values([{ name: "Chef", type: :multi_string, data: %w{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 => %w{OpscodeOrange Rules} })).to eq(true)
+      expect(@registry.value_exists?(reg_child + '\OpscodeTest', { name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} })).to eq(true)
     end
 
     it "raises an 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)
     end
 
     it "raises an error if action create and type key missing in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC", :data => "my_data" }])
+      @new_resource.values([{ name: "OC", data: "my_data" }])
       expect { @new_resource.run_action(:create) }.to raise_error(Chef::Exceptions::RegKeyValuesTypeMissing)
     end
 
     it "raises an error if action create and data key missing in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC", :type => :string }])
+      @new_resource.values([{ name: "OC", type: :string }])
       expect { @new_resource.run_action(:create) }.to raise_error(Chef::Exceptions::RegKeyValuesDataMissing)
     end
 
     it "raises an error if action create and only name key present in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC" }])
+      @new_resource.values([{ name: "OC" }])
       expect { @new_resource.run_action(:create) }.to raise_error(Chef::Exceptions::RegKeyValuesTypeMissing)
     end
 
     it "does not raise an error if action create and all keys are present in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC", :type => :string, :data => "my_data" }])
+      @new_resource.values([{ name: "OC", type: :string, data: "my_data" }])
       expect { @new_resource.run_action(:create) }.to_not raise_error
     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)
 
@@ -259,12 +259,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
@@ -272,7 +272,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
@@ -281,8 +281,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")
@@ -296,7 +296,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not raise 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)
@@ -305,7 +305,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       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)
@@ -313,28 +313,28 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not raise an exception if the action create and type key missing in values hash" do
         @new_resource.key(reg_child + '\Slitheen')
-        @new_resource.values([{ :name => "BriskWalk", :data => "my_data" }])
+        @new_resource.values([{ name: "BriskWalk", data: "my_data" }])
         @new_resource.run_action(:create) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
       end
 
       it "does not raise an exception if the action create and data key missing in values hash" do
         @new_resource.key(reg_child + '\Slitheen')
-        @new_resource.values([{ :name => "BriskWalk", :type => :string }])
+        @new_resource.values([{ name: "BriskWalk", type: :string }])
         @new_resource.run_action(:create) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
       end
 
       it "does not raise an exception if the action create and only name key present in values hash" do
         @new_resource.key(reg_child + '\Slitheen')
-        @new_resource.values([{ :name => "BriskWalk" }])
+        @new_resource.values([{ name: "BriskWalk" }])
         @new_resource.run_action(:create) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
       end
 
       it "does not raise an exception if the action create and all keys are present in values hash" do
         @new_resource.key(reg_child + '\Slitheen')
-        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "my_data" }])
+        @new_resource.values([{ name: "BriskWalk", type: :string, data: "my_data" }])
         @new_resource.run_action(:create) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Slitheen')).to eq(false)
       end
@@ -348,85 +348,85 @@ 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 => %w{OpscodeOrange Rules} }])
+      @new_resource.values([{ name: "Chef", type: :multi_string, data: %w{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 => %w{OpscodeOrange Rules} })).to eq(true)
+      expect(@registry.value_exists?(reg_child + '\Pyrovile', { name: "Chef", type: :multi_string, data: %w{OpscodeOrange Rules} })).to eq(true)
     end
 
     it "raises an 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)
     end
 
     it "raises an error if action create_if_missing and type key missing in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC", :data => "my_data" }])
+      @new_resource.values([{ name: "OC", data: "my_data" }])
       expect { @new_resource.run_action(:create_if_missing) }.to raise_error(Chef::Exceptions::RegKeyValuesTypeMissing)
     end
 
     it "raises an error if action create_if_missing and data key missing in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC", :type => :string }])
+      @new_resource.values([{ name: "OC", type: :string }])
       expect { @new_resource.run_action(:create_if_missing) }.to raise_error(Chef::Exceptions::RegKeyValuesDataMissing)
     end
 
     it "raises an error if action create_if_missing and only name key present in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC" }])
+      @new_resource.values([{ name: "OC" }])
       expect { @new_resource.run_action(:create_if_missing) }.to raise_error(Chef::Exceptions::RegKeyValuesTypeMissing)
     end
 
     it "does not raise an error if action create_if_missing and all keys are present in values hash" do
       @new_resource.key(reg_child)
-      @new_resource.values([{ :name => "OC", :type => :string, :data => "my_data" }])
+      @new_resource.values([{ name: "OC", type: :string, data: "my_data" }])
       expect { @new_resource.run_action(:create_if_missing) }.to_not raise_error
     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)
 
@@ -437,7 +437,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
@@ -446,7 +446,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")
@@ -460,7 +460,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not raise 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)
@@ -469,7 +469,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       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)
@@ -477,28 +477,28 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
       it "does not raise an exception if the action create_if_missing and type key missing in values hash" do
         @new_resource.key(reg_child + '\Zygons')
-        @new_resource.values([{ :name => "BriskWalk", :data => "my_data" }])
+        @new_resource.values([{ name: "BriskWalk", data: "my_data" }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and data key missing in values hash" do
         @new_resource.key(reg_child + '\Zygons')
-        @new_resource.values([{ :name => "BriskWalk", :type => :string }])
+        @new_resource.values([{ name: "BriskWalk", type: :string }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and only name key present in values hash" do
         @new_resource.key(reg_child + '\Zygons')
-        @new_resource.values([{ :name => "BriskWalk" }])
+        @new_resource.values([{ name: "BriskWalk" }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
       end
 
       it "does not raise an exception if the action create_if_missing and all keys are present in values hash" do
         @new_resource.key(reg_child + '\Zygons')
-        @new_resource.values([{ :name => "BriskWalk", :type => :string, :data => "my_data" }])
+        @new_resource.values([{ name: "BriskWalk", type: :string, data: "my_data" }])
         @new_resource.run_action(:create_if_missing) # should not raise_error
         expect(@registry.key_exists?(reg_child + '\Zygons')).to eq(false)
       end
@@ -522,54 +522,54 @@ 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 => %w{SeattleGrey OCOrange} }])
+      @new_resource.values([{ name: "LooksLike", type: :multi_string, data: %w{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 => %w{Seattle Washington} }, { :name => "AKA", :type => :string, :data => "OC" }])
+      @new_resource.values([{ name: "Opscode", type: :multi_string, data: %w{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 => %w{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: %w{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 => %w{Black Orange} }])
+      @new_resource.values([{ name: "Color", type: :multi_string, data: %w{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" }])
-      #Not testing for after values to match since after -> new_resource values.
+      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")
       expect(@report["total_res_count"]).to eq("1")
@@ -581,7 +581,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)
 
@@ -622,7 +622,7 @@ describe Chef::Resource::RegistryKey, :windows_only, :broken => true do
 
     it "ignores the values under a key" do
       @new_resource.key(reg_parent + '\OpscodeIgnoredValues')
-      #@new_resource.values([{:name=>"DontExist", :type=>:string, :data=>"These will be ignored anyways"}])
+      # @new_resource.values([{:name=>"DontExist", :type=>:string, :data=>"These will be ignored anyways"}])
       @new_resource.recursive(true)
       @new_resource.run_action(:delete_key)
     end
@@ -645,9 +645,9 @@ 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_parent + '\ReportKey')
-      #Not testing for before or after values to match since
-      #after -> new_resource.values and
-      #before -> current_resource.values
+      # Not testing for before or after values to match since
+      # after -> new_resource.values and
+      # before -> current_resource.values
       expect(@report["resources"][0]["result"]).to eq("delete_key")
       expect(@report["status"]).to eq("success")
       expect(@report["total_res_count"]).to eq("1")
@@ -659,13 +659,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)