chef 12.19.36 → 14.14.25

data/spec/functional/resource/mount_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Copyright:: Copyright 2013-2016, Chef Software Inc.
+# Copyright:: Copyright 2013-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,9 +22,9 @@ require "chef/mixin/shell_out"
 require "tmpdir"
 
 # run this test only for following platforms.
-include_flag = !(%w{ubuntu centos aix solaris2}.include?(ohai[:platform]))
+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
 
@@ -35,15 +35,19 @@ describe Chef::Resource::Mount, :requires_root, :skip_travis, :external => inclu
   def setup_device_for_mount
     # use ramdisk for creating a test device for mount.
     # This can cleaner if we have chef resource/provider for ramdisk.
-    case ohai[:platform]
+    case ohai[:platform_family]
     when "aix"
       # On AIX, we can't create a ramdisk inside a WPAR, so we use
       # a "namefs" mount against / to test
       # https://www-304.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.performance/namefs_file_sys.htm
       device = "/"
       fstype = "namefs"
-    when "ubuntu", "centos"
+    when "debian", "rhel", "amazon"
       device = "/dev/ram1"
+      unless File.exist?(device)
+        shell_out("mknod -m 660 #{device} b 1 0")
+        shell_out("chown root:disk #{device}")
+      end
       shell_out("ls -1 /dev/ram*").stdout.each_line do |d|
         if shell_out("mount | grep #{d}").exitstatus == "1"
           # this device is not mounted, so use it.
@@ -157,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/msu_package_spec.rb

@@ -76,6 +76,20 @@ describe Chef::Resource::MsuPackage, :win2012r2_only do
     end
   end
 
+  context "when an msu package is not applicable to the image." do
+    def package_name
+      "Package_for_KB4019990"
+    end
+
+    def package_source
+      "http://download.windowsupdate.com/c/msdownload/update/software/updt/2017/05/windows8-rt-kb4019990-x64_a77f4e3e1f2d47205824763e7121bb11979c2716.msu"
+    end
+
+    it "raises error while installing" do
+      expect { subject.run_action(:install) }.to raise_error(Chef::Exceptions::Package, /The specified package is not applicable to this image./)
+    end
+  end
+
   def remove_package
     pkg_to_remove = Chef::Resource::MsuPackage.new(package_name, run_context)
     pkg_to_remove.source = package_source

data/spec/functional/resource/powershell_script_spec.rb

@@ -36,15 +36,13 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
   let(:cmdlet_exit_code_success_content) { "get-item ." }
   let(:windows_process_exit_code_success_content) { "#{ENV['SystemRoot']}\\system32\\attrib.exe $env:systemroot" }
   let(:windows_process_exit_code_not_found_content) { "findstr /notavalidswitch" }
-  # Note that process exit codes on 32-bit Win2k3 cannot
-  # exceed maximum value of signed integer
   let(:arbitrary_nonzero_process_exit_code) { 4193 }
   let(:arbitrary_nonzero_process_exit_code_content) { "exit #{arbitrary_nonzero_process_exit_code}" }
   let(:invalid_powershell_interpreter_flag) { "/thisflagisinvalid" }
   let(:valid_powershell_interpreter_flag) { "-Sta" }
 
   let!(:resource) do
-    r = Chef::Resource::WindowsScript::PowershellScript.new("Powershell resource functional test", @run_context)
+    r = Chef::Resource::WindowsScript::PowershellScript.new("PowerShell resource functional test", @run_context)
     r.code(successful_executable_script_content)
     r
   end
@@ -156,7 +154,7 @@ describe Chef::Resource::WindowsScript::PowershellScript, :windows_only do
     # This somewhat ambiguous case, two failures of different types,
     # seems to violate the principle of returning the status of the
     # last line executed -- in this case, we return the status of the
-    # second to last line. This happens because Powershell gives no
+    # second to last line. This happens because PowerShell gives no
     # way for us to determine whether the last operation was a cmdlet
     # or Windows process. Because the latter gives more specific
     # errors than 0 or 1, we return that instead, which is acceptable
@@ -257,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
@@ -476,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
 
@@ -583,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

@@ -1,7 +1,7 @@
 #
 # Author:: Prajakta Purohit (<prajakta@chef.io>)
 # Author:: Lamont Granquist (<lamont@chef.io>)
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# Copyright:: Copyright 2011-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -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,8 +123,8 @@ 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")
-    allow(@new_resource).to receive(:cookbook_version).and_return(@cookbook_version)
+    @cookbook_version = double("Cookbook::Version", version: "1.2.3")
+    @new_resource.cookbook_version(@cookbook_version)
   end
 
   after (:all) do
@@ -137,114 +137,114 @@ 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)
 
-      @new_resource.values.each do |value|
+      @new_resource.each_value do |value|
         expect(@registry.value_exists?(reg_child, value)).to eq(true)
       end
     end
@@ -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,96 +348,96 @@ 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)
 
-      @new_resource.values.each do |value|
+      @new_resource.each_value do |value|
         expect(@registry.value_exists?(reg_child + '\Adipose', value)).to eq(true)
       end
     end
 
     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)