chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/spec/unit/provider/package/solaris_spec.rb

@@ -32,37 +32,37 @@ describe Chef::Provider::Package::Solaris do
 
   describe "assessing the current package status" do
     before do
-      @pkginfo = <<-PKGINFO
-PKGINST:  SUNWbash
-NAME:  GNU Bourne-Again shell (bash)
-CATEGORY:  system
-ARCH:  sparc
-VERSION:  11.10.0,REV=2005.01.08.05.16
-BASEDIR:  /
-VENDOR:  Sun Microsystems, Inc.
-DESC:  GNU Bourne-Again shell (bash) version 3.0
-PSTAMP:  sfw10-patch20070430084444
-INSTDATE:  Nov 04 2009 01:02
-HOTLINE:  Please contact your local service provider
+      @pkginfo = <<~PKGINFO
+        PKGINST:  SUNWbash
+        NAME:  GNU Bourne-Again shell (bash)
+        CATEGORY:  system
+        ARCH:  sparc
+        VERSION:  11.10.0,REV=2005.01.08.05.16
+        BASEDIR:  /
+        VENDOR:  Sun Microsystems, Inc.
+        DESC:  GNU Bourne-Again shell (bash) version 3.0
+        PSTAMP:  sfw10-patch20070430084444
+        INSTDATE:  Nov 04 2009 01:02
+        HOTLINE:  Please contact your local service provider
 PKGINFO
 
-      @status = double("Status", :stdout => "", :exitstatus => 0)
+      @status = double("Status", stdout: "", exitstatus: 0)
     end
 
     it "should create a current resource with the name of new_resource" do
-      allow(@provider).to receive(:shell_out).and_return(@status)
+      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
       @provider.load_current_resource
       expect(@provider.current_resource.name).to eq("SUNWbash")
     end
 
     it "should set the current reource package name to the new resource package name" do
-      allow(@provider).to receive(:shell_out).and_return(@status)
+      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
       @provider.load_current_resource
       expect(@provider.current_resource.package_name).to eq("SUNWbash")
     end
 
     it "should raise an exception if a source is supplied but not found" do
-      allow(@provider).to receive(:shell_out).and_return(@status)
+      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
       allow(::File).to receive(:exist?).and_return(false)
       @provider.load_current_resource
       @provider.define_resource_requirements
@@ -70,9 +70,9 @@ PKGINFO
     end
 
     it "should get the source package version from pkginfo if provided" do
-      status = double(:stdout => @pkginfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(status)
-      expect(@provider).to receive(:shell_out).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(@status)
+      status = double(stdout: @pkginfo, exitstatus: 0)
+      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(status)
+      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(@status)
       @provider.load_current_resource
 
       expect(@provider.current_resource.package_name).to eq("SUNWbash")
@@ -80,9 +80,9 @@ PKGINFO
     end
 
     it "should return the current version installed if found by pkginfo" do
-      status = double(:stdout => @pkginfo, :exitstatus => 0)
-      expect(@provider).to receive(:shell_out).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(@status)
-      expect(@provider).to receive(:shell_out).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(status)
+      status = double(stdout: @pkginfo, exitstatus: 0)
+      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(@status)
+      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(status)
       @provider.load_current_resource
       expect(@provider.current_resource.version).to eq("11.10.0,REV=2005.01.08.05.16")
     end
@@ -90,19 +90,19 @@ PKGINFO
     it "should raise an exception if the source is not set but we are installing" do
       @new_resource = Chef::Resource::Package.new("SUNWbash")
       @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
-      allow(@provider).to receive(:shell_out).and_return(@status)
+      allow(@provider).to receive(:shell_out_compacted).and_return(@status)
       expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should raise an exception if pkginfo fails to run" do
-      status = double(:stdout => "", :exitstatus => -1)
-      allow(@provider).to receive(:shell_out).and_return(status)
+      status = double(stdout: "", exitstatus: -1)
+      allow(@provider).to receive(:shell_out_compacted).and_return(status)
       expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
     end
 
     it "should return a current resource with a nil version if the package is not found" do
-      expect(@provider).to receive(:shell_out).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(@status)
-      expect(@provider).to receive(:shell_out).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(@status)
+      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "-d", "/tmp/bash.pkg", "SUNWbash", { timeout: 900 }).and_return(@status)
+      expect(@provider).to receive(:shell_out_compacted).with("pkginfo", "-l", "SUNWbash", { timeout: 900 }).and_return(@status)
       @provider.load_current_resource
       expect(@provider.current_resource.version).to be_nil
     end
@@ -111,20 +111,20 @@ PKGINFO
   describe "candidate_version" do
     it "should return the candidate_version variable if already setup" do
       @provider.candidate_version = "11.10.0,REV=2005.01.08.05.16"
-      expect(@provider).not_to receive(:shell_out)
+      expect(@provider).not_to receive(:shell_out_compacted)
       @provider.candidate_version
     end
 
     it "should lookup the candidate_version if the variable is not already set" do
-      status = double(:stdout => "", :exitstatus => 0)
-      allow(@provider).to receive(:shell_out).and_return(status)
-      expect(@provider).to receive(:shell_out)
+      status = double(stdout: "", exitstatus: 0)
+      allow(@provider).to receive(:shell_out_compacted).and_return(status)
+      expect(@provider).to receive(:shell_out_compacted)
       @provider.candidate_version
     end
 
     it "should throw and exception if the exitstatus is not 0" do
-      status = double(:stdout => "", :exitstatus => 1)
-      allow(@provider).to receive(:shell_out).and_return(status)
+      status = double(stdout: "", exitstatus: 1)
+      allow(@provider).to receive(:shell_out_compacted).and_return(status)
       expect { @provider.candidate_version }.to raise_error(Chef::Exceptions::Package)
     end
 
@@ -132,7 +132,7 @@ PKGINFO
 
   describe "install and upgrade" do
     it "should run pkgadd -n -d with the package source to install" do
-      expect(@provider).to receive(:shell_out!).with("pkgadd", "-n", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
+      expect(@provider).to receive(:shell_out_compacted!).with("pkgadd", "-n", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
       @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
 
@@ -140,26 +140,26 @@ PKGINFO
       @new_resource = Chef::Resource::Package.new("/tmp/bash.pkg")
       @provider = Chef::Provider::Package::Solaris.new(@new_resource, @run_context)
       expect(@new_resource.source).to eq("/tmp/bash.pkg")
-      expect(@provider).to receive(:shell_out!).with("pkgadd", "-n", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
+      expect(@provider).to receive(:shell_out_compacted!).with("pkgadd", "-n", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
       @provider.install_package("/tmp/bash.pkg", "11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should run pkgadd -n -a /tmp/myadmin -d with the package options -a /tmp/myadmin" do
       @new_resource.options "-a /tmp/myadmin"
-      expect(@provider).to receive(:shell_out!).with("pkgadd", "-n", "-a", "/tmp/myadmin", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
+      expect(@provider).to receive(:shell_out_compacted!).with("pkgadd", "-n", "-a", "/tmp/myadmin", "-d", "/tmp/bash.pkg", "all", { timeout: 900 })
       @provider.install_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
   end
 
   describe "remove" do
     it "should run pkgrm -n to remove the package" do
-      expect(@provider).to receive(:shell_out!).with("pkgrm", "-n", "SUNWbash", { timeout: 900 })
+      expect(@provider).to receive(:shell_out_compacted!).with("pkgrm", "-n", "SUNWbash", { timeout: 900 })
       @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
 
     it "should run pkgrm -n -a /tmp/myadmin with options -a /tmp/myadmin" do
       @new_resource.options "-a /tmp/myadmin"
-      expect(@provider).to receive(:shell_out!).with("pkgrm", "-n", "-a", "/tmp/myadmin", "SUNWbash", { timeout: 900 })
+      expect(@provider).to receive(:shell_out_compacted!).with("pkgrm", "-n", "-a", "/tmp/myadmin", "SUNWbash", { timeout: 900 })
       @provider.remove_package("SUNWbash", "11.10.0,REV=2005.01.08.05.16")
     end
 

data/spec/unit/provider/package/windows/exe_spec.rb

@@ -126,7 +126,7 @@ describe Chef::Provider::Package::Windows::Exe do
       it "removes installed package and quotes uninstall string" do
         new_resource.timeout = 300
         allow(::File).to receive(:exist?).with("uninst_dir/uninst_file").and_return(true)
-        expect(provider).to receive(:shell_out!).with(/start \"\" \/wait \"uninst_dir\/uninst_file\" \/S \/NCRC & exit %%%%ERRORLEVEL%%%%/, :timeout => 300, :returns => [0])
+        expect(provider).to receive(:shell_out!).with(/start \"\" \/wait \"uninst_dir\/uninst_file\" \/S \/NCRC & exit %%%%ERRORLEVEL%%%%/, timeout: 300, returns: [0])
         provider.remove_package
       end
     end

data/spec/unit/provider/package/windows/msi_spec.rb

@@ -22,7 +22,7 @@ require "chef/provider/package/windows/msi"
 describe Chef::Provider::Package::Windows::MSI do
   let(:node) { double("Chef::Node") }
   let(:events) { double("Chef::Events").as_null_object } # mock all the methods
-  let(:run_context) { double("Chef::RunContext", :node => node, :events => events) }
+  let(:run_context) { double("Chef::RunContext", node: node, events: events) }
   let(:package_name) { "calculator" }
   let(:resource_source) { "calculator.msi" }
   let(:resource_version) { nil }

data/spec/unit/provider/package/windows_spec.rb

@@ -50,7 +50,7 @@ describe Chef::Provider::Package::Windows, :windows_only do
       before(:each) do
         allow(Chef::Util::PathHelper).to receive(:validate_path)
         allow(provider).to receive(:package_provider).and_return(double("package_provider",
-          :installed_version => "1.0", :package_version => "2.0"))
+          installed_version: "1.0", package_version: "2.0"))
       end
 
       it "creates a current resource with the name of the new resource" do
@@ -398,13 +398,20 @@ describe Chef::Provider::Package::Windows, :windows_only do
     context "a missing local file is given" do
       let(:resource_source) { "C:/a_missing_file.exe" }
       let(:installer_type) { nil }
-
-      it "raises a Package error" do
+      before do
         allow(::File).to receive(:exist?).with(provider.new_resource.source).and_return(false)
-
         provider.load_current_resource
+      end
+
+      it "raises a Package error" do
         expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
       end
+
+      it "why_run mode doesn't raise an error" do
+        Chef::Config[:why_run] = true
+        expect { provider.run_action(:install) }.not_to raise_error
+        Chef::Config[:why_run] = false
+      end
     end
   end
 

data/spec/unit/provider/package/zypper_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2017, Chef Software Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,22 +30,22 @@ describe Chef::Provider::Package::Zypper do
     Chef::Provider::Package::Zypper.new(new_resource, run_context)
   end
 
-  let(:status) { double(:stdout => "\n", :exitstatus => 0) }
+  let(:status) { double(stdout: "\n", exitstatus: 0) }
 
   before(:each) do
     allow(Chef::Resource::Package).to receive(:new).and_return(current_resource)
-    allow(provider).to receive(:shell_out!).and_return(status)
+    allow(provider).to receive(:shell_out_compacted!).and_return(status)
     allow(provider).to receive(:`).and_return("2.0")
   end
 
   def shell_out_expectation(*command, **options)
     options[:timeout] ||= 900
-    expect(provider).to receive(:shell_out).with(*command, **options)
+    expect(provider).to receive(:shell_out_compacted).with(*command, **options)
   end
 
   def shell_out_expectation!(*command, **options)
     options[:timeout] ||= 900
-    expect(provider).to receive(:shell_out!).with(*command, **options)
+    expect(provider).to receive(:shell_out_compacted!).with(*command, **options)
   end
 
   describe "when loading the current package state" do
@@ -67,47 +67,47 @@ describe Chef::Provider::Package::Zypper do
     end
 
     it "should set the installed version to nil on the current resource if zypper info installed version is (none)" do
-      allow(provider).to receive(:shell_out).and_return(status)
+      allow(provider).to receive(:shell_out_compacted).and_return(status)
       expect(current_resource).to receive(:version).with([nil]).and_return(true)
       provider.load_current_resource
     end
 
     it "should set the installed version if zypper info has one (zypper version < 1.13.0)" do
-      status = double(:stdout => "Version: 1.0\nInstalled: Yes\n", :exitstatus => 0)
+      status = double(stdout: "Version: 1.0\nInstalled: Yes\n", exitstatus: 0)
 
-      allow(provider).to receive(:shell_out!).and_return(status)
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
       expect(current_resource).to receive(:version).with(["1.0"]).and_return(true)
       provider.load_current_resource
     end
 
     it "should set the installed version if zypper info has one (zypper version >= 1.13.0)" do
-      status = double(:stdout => "Version        : 1.0                             \nInstalled      : Yes                             \n", :exitstatus => 0)
+      status = double(stdout: "Version        : 1.0                             \nInstalled      : Yes                             \n", exitstatus: 0)
 
-      allow(provider).to receive(:shell_out!).and_return(status)
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
       expect(current_resource).to receive(:version).with(["1.0"]).and_return(true)
       provider.load_current_resource
     end
 
     it "should set the installed version if zypper info has one (zypper version >= 1.13.17)" do
-      status = double(:stdout => "Version        : 1.0\nInstalled      : Yes (automatically)\n", :exitstatus => 0)
+      status = double(stdout: "Version        : 1.0\nInstalled      : Yes (automatically)\n", exitstatus: 0)
 
-      allow(provider).to receive(:shell_out!).and_return(status)
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
       expect(current_resource).to receive(:version).with(["1.0"]).and_return(true)
       provider.load_current_resource
     end
 
     it "should set the candidate version if zypper info has one (zypper version < 1.13.0)" do
-      status = double(:stdout => "Version: 1.0\nInstalled: No\nStatus: out-of-date (version 0.9 installed)", :exitstatus => 0)
+      status = double(stdout: "Version: 1.0\nInstalled: No\nStatus: out-of-date (version 0.9 installed)", exitstatus: 0)
 
-      allow(provider).to receive(:shell_out!).and_return(status)
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
       provider.load_current_resource
       expect(provider.candidate_version).to eql(["1.0"])
     end
 
     it "should set the candidate version if zypper info has one (zypper version >= 1.13.0)" do
-      status = double(:stdout => "Version        : 1.0                             \nInstalled      : No                              \nStatus         : out-of-date (version 0.9 installed)", :exitstatus => 0)
+      status = double(stdout: "Version        : 1.0                             \nInstalled      : No                              \nStatus         : out-of-date (version 0.9 installed)", exitstatus: 0)
 
-      allow(provider).to receive(:shell_out!).and_return(status)
+      allow(provider).to receive(:shell_out_compacted!).and_return(status)
       provider.load_current_resource
       expect(provider.candidate_version).to eql(["1.0"])
     end
@@ -269,35 +269,33 @@ describe Chef::Provider::Package::Zypper do
 
   describe "action_lock" do
     it "should lock if the package is not already locked" do
-      prov = provider
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "--non-interactive", "info", new_resource.package_name
+      expect(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "--non-interactive", "info", new_resource.package_name, timeout: 900
       ).and_return(status)
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "locks"
+      expect(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "locks", timeout: 900
       ).and_return(instance_double(
         Mixlib::ShellOut, stdout: "1 | somethingelse | package | (any)"
       ))
-      expect(prov).to receive(:lock_package).with(["cups"], [nil])
+      expect(provider).to receive(:lock_package).with(["cups"], [nil])
 
-      prov.load_current_resource
-      prov.action_lock
+      provider.load_current_resource
+      provider.action_lock
     end
 
     it "should not lock if the package is already locked" do
-      prov = provider
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "--non-interactive", "info", new_resource.package_name
+      expect(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "--non-interactive", "info", new_resource.package_name, timeout: 900
       ).and_return(status)
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "locks"
+      expect(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "locks", timeout: 900
       ).and_return(instance_double(
         Mixlib::ShellOut, stdout: "1 | cups | package | (any)"
       ))
-      expect(prov).to_not receive(:lock_package)
+      expect(provider).to_not receive(:lock_package)
 
-      prov.load_current_resource
-      prov.action_lock
+      provider.load_current_resource
+      provider.action_lock
     end
   end
 
@@ -326,33 +324,31 @@ describe Chef::Provider::Package::Zypper do
 
   describe "action_unlock" do
     it "should unlock if the package is not already unlocked" do
-      prov = provider
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "--non-interactive", "info", new_resource.package_name
+      allow(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "--non-interactive", "info", new_resource.package_name, timeout: 900
       ).and_return(status)
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "locks"
+      allow(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "locks", timeout: 900
       ).and_return(instance_double(
         Mixlib::ShellOut, stdout: "1 | cups | package | (any)"
       ))
-      expect(prov).to receive(:unlock_package).with(["cups"], [nil])
+      expect(provider).to receive(:unlock_package).with(["cups"], [nil])
 
-      prov.load_current_resource
+      provider.load_current_resource
       provider.action_unlock
     end
     it "should not unlock if the package is already unlocked" do
-      prov = provider
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "--non-interactive", "info", new_resource.package_name
+      allow(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "--non-interactive", "info", new_resource.package_name, timeout: 900
       ).and_return(status)
-      allow(prov).to receive(:shell_out_compact_timeout!).with(
-        "zypper", "locks"
+      allow(provider).to receive(:shell_out_compacted!).with(
+        "zypper", "locks", timeout: 900
       ).and_return(instance_double(
         Mixlib::ShellOut, stdout: "1 | somethingelse | package | (any)"
       ))
-      expect(prov).to_not receive(:unlock_package)
+      expect(provider).to_not receive(:unlock_package)
 
-      prov.load_current_resource
+      provider.load_current_resource
       provider.action_unlock
     end
   end

data/spec/unit/provider/package_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, Inc.
+# Copyright:: Copyright 2008-2018, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -942,7 +942,7 @@ describe "Chef::Provider::Package - Multi" do
     end
 
     [ :shell_out_with_timeout, :shell_out_with_timeout! ].each do |method|
-      stubbed_method = method == :shell_out_with_timeout! ? :shell_out! : :shell_out
+      stubbed_method = method == :shell_out_with_timeout! ? :shell_out_compacted! : :shell_out_compacted
       [ %w{command arg1 arg2}, "command arg1 arg2" ].each do |command|
         it "#{method} defaults to 900 seconds" do
           expect(provider).to receive(stubbed_method).with(*command, timeout: 900)

data/spec/unit/provider/powershell_script_spec.rb

@@ -25,7 +25,7 @@ describe Chef::Provider::PowershellScript, "action_run" do
     node.default["kernel"] = Hash.new
     node.default["kernel"][:machine] = :x86_64.to_s
     if ! powershell_version.nil?
-      node.default[:languages] = { :powershell => { :version => powershell_version } }
+      node.default[:languages] = { powershell: { version: powershell_version } }
     end
     node
   end

data/spec/unit/provider/registry_key_spec.rb

@@ -275,20 +275,20 @@ describe Chef::Provider::RegistryKey do
 
   context "when the key data is safe" do
     let(:keyname) { 'HKLM\Software\Opscode\Testing\Safe' }
-    let(:testval1) { { :name => "one", :type => :string, :data => "1" } }
-    let(:testval1_wrong_type) { { :name => "one", :type => :multi_string, :data => "1" } }
-    let(:testval1_wrong_data) { { :name => "one", :type => :string, :data => "2" } }
-    let(:testval2) { { :name => "two", :type => :string, :data => "2" } }
+    let(:testval1) { { name: "one", type: :string, data: "1" } }
+    let(:testval1_wrong_type) { { name: "one", type: :multi_string, data: "1" } }
+    let(:testval1_wrong_data) { { name: "one", type: :string, data: "2" } }
+    let(:testval2) { { name: "two", type: :string, data: "2" } }
 
     it_should_behave_like "a registry key"
   end
 
   context "when the key data is unsafe" do
     let(:keyname) { 'HKLM\Software\Opscode\Testing\Unsafe' }
-    let(:testval1) { { :name => "one", :type => :binary, :data => 255.chr * 1 } }
-    let(:testval1_wrong_type) { { :name => "one", :type => :string, :data => 255.chr * 1 } }
-    let(:testval1_wrong_data) { { :name => "one", :type => :binary, :data => 254.chr * 1 } }
-    let(:testval2) { { :name => "two", :type => :binary, :data => 0.chr * 1 } }
+    let(:testval1) { { name: "one", type: :binary, data: 255.chr * 1 } }
+    let(:testval1_wrong_type) { { name: "one", type: :string, data: 255.chr * 1 } }
+    let(:testval1_wrong_data) { { name: "one", type: :binary, data: 254.chr * 1 } }
+    let(:testval2) { { name: "two", type: :binary, data: 0.chr * 1 } }
 
     it_should_behave_like "a registry key"
   end
@@ -296,8 +296,8 @@ describe Chef::Provider::RegistryKey do
   describe "action_create" do
     context "when key exists and type matches" do
       let(:keyname) { 'hklm\\software\\opscode\\testing\\dword' }
-      let(:dword_passed_as_integer) { { :name => "one", :type => :dword, :data => 12345 } }
-      let(:testval1) { { :name => "one", :type => :dword, :data => "12345" } }
+      let(:dword_passed_as_integer) { { name: "one", type: :dword, data: 12345 } }
+      let(:testval1) { { name: "one", type: :dword, data: "12345" } }
       before do
         expect(@double_registry).to receive(:key_exists?).twice.with(keyname).and_return(true)
       end
@@ -321,33 +321,33 @@ describe Chef::Provider::RegistryKey, "key_missing?" do
   let(:provider) { Chef::Provider::RegistryKey.new(new_resource, run_context) }
 
   let(:all_keys_present_in_all_hash) do
-    [ { :name => "input1_value1", :type => :string, :data => "my_value1" },
-      { :name => "input1_value2", :type => :string, :data => "my_value2" },
+    [ { name: "input1_value1", type: :string, data: "my_value1" },
+      { name: "input1_value2", type: :string, data: "my_value2" },
     ]
   end
   let(:type_key_not_present_in_any_hash) do
-    [ { :name => "input2_value1", :data => "my_value1" },
-      { :name => "input2_value2", :data => "my_value2" },
+    [ { name: "input2_value1", data: "my_value1" },
+      { name: "input2_value2", data: "my_value2" },
     ]
   end
   let(:type_key_not_present_in_some_hash) do
-    [ { :name => "input3_value1", :data => "my_value1" },
-      { :name => "input3_value2", :type => :string, :data => "my_value2" },
+    [ { name: "input3_value1", data: "my_value1" },
+      { name: "input3_value2", type: :string, data: "my_value2" },
     ]
   end
   let(:data_key_not_present_in_any_hash) do
-    [ { :name => "input4_value1", :type => :string },
-      { :name => "input4_value2", :type => :string },
+    [ { name: "input4_value1", type: :string },
+      { name: "input4_value2", type: :string },
     ]
   end
   let(:data_key_not_present_in_some_hash) do
-    [ { :name => "input5_value1", :type => :string, :data => "my_value1" },
-      { :name => "input5_value2", :type => :string },
+    [ { name: "input5_value1", type: :string, data: "my_value1" },
+      { name: "input5_value2", type: :string },
     ]
   end
   let(:only_name_key_present_in_all_hash) do
-    [ { :name => "input6_value1" },
-      { :name => "input6_value2" },
+    [ { name: "input6_value1" },
+      { name: "input6_value2" },
     ]
   end