chef 11.14.0.alpha.4-x86-mingw32 → 11.14.0.rc.2-x86-mingw32

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

@@ -24,8 +24,8 @@ describe Chef::Provider::Package::Rpm do
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
-    @new_resource = Chef::Resource::Package.new("emacs")
-    @new_resource.source "/tmp/emacs-21.4-20.el5.i386.rpm"
+    @new_resource = Chef::Resource::Package.new("ImageMagick-c++")
+    @new_resource.source "/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
 
     @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
 
@@ -38,13 +38,13 @@ describe Chef::Provider::Package::Rpm do
     it "should create a current resource with the name of new_resource" do
       @provider.stub(:popen4).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.name.should == "emacs"
+      @provider.current_resource.name.should == "ImageMagick-c++"
     end
 
     it "should set the current reource package name to the new resource package name" do
       @provider.stub(:popen4).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == 'emacs'
+      @provider.current_resource.package_name.should == 'ImageMagick-c++'
     end
 
     it "should raise an exception if a source is supplied but not found" do
@@ -53,24 +53,24 @@ describe Chef::Provider::Package::Rpm do
     end
 
     it "should get the source package version from rpm if provided" do
-      @stdout = StringIO.new("emacs 21.4-20.el5")
-      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/emacs-21.4-20.el5.i386.rpm").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
-      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' emacs").and_return(@status)
+      @stdout = StringIO.new("ImageMagick-c++ 6.5.4.7-7.el6_5")
+      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' ImageMagick-c++").and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.package_name.should == "emacs"
-      @provider.new_resource.version.should == "21.4-20.el5"
+      @provider.current_resource.package_name.should == "ImageMagick-c++"
+      @provider.new_resource.version.should == "6.5.4.7-7.el6_5"
     end
 
     it "should return the current version installed if found by rpm" do
-      @stdout = StringIO.new("emacs 21.4-20.el5")
-      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/emacs-21.4-20.el5.i386.rpm").and_return(@status)
-      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' emacs").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+      @stdout = StringIO.new("ImageMagick-c++ 6.5.4.7-7.el6_5")
+      @provider.should_receive(:popen4).with("rpm -qp --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm").and_return(@status)
+      @provider.should_receive(:popen4).with("rpm -q --queryformat '%{NAME} %{VERSION}-%{RELEASE}\n' ImageMagick-c++").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
       @provider.load_current_resource
-      @provider.current_resource.version.should == "21.4-20.el5"
+      @provider.current_resource.version.should == "6.5.4.7-7.el6_5"
     end
 
     it "should raise an exception if the source is not set but we are installing" do
-      new_resource = Chef::Resource::Package.new("emacs")
+      new_resource = Chef::Resource::Package.new("ImageMagick-c++")
       provider = Chef::Provider::Package::Rpm.new(new_resource, @run_context)
       lambda { provider.run_action(:any) }.should raise_error(Chef::Exceptions::Package)
     end
@@ -84,56 +84,64 @@ describe Chef::Provider::Package::Rpm do
 
   describe "after the current resource is loaded" do
     before do
-      @current_resource = Chef::Resource::Package.new("emacs")
+      @current_resource = Chef::Resource::Package.new("ImageMagick-c++")
       @provider.current_resource = @current_resource
     end
 
     describe "when installing or upgrading" do
       it "should run rpm -i with the package source to install" do
         @provider.should_receive(:run_command_with_systems_locale).with({
-          :command => "rpm  -i /tmp/emacs-21.4-20.el5.i386.rpm"
+          :command => "rpm  -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
         })
-        @provider.install_package("emacs", "21.4-20.el5")
+        @provider.install_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
 
       it "should run rpm -U with the package source to upgrade" do
         @current_resource.version("21.4-19.el5")
         @provider.should_receive(:run_command_with_systems_locale).with({
-          :command => "rpm  -U /tmp/emacs-21.4-20.el5.i386.rpm"
+          :command => "rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
         })
-        @provider.upgrade_package("emacs", "21.4-20.el5")
+        @provider.upgrade_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
+      end
+
+      it "should install package if missing and set to upgrade" do
+        @current_resource.version("ImageMagick-c++")
+        @provider.should_receive(:run_command_with_systems_locale).with({
+          :command => "rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
+        })
+        @provider.upgrade_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
 
       it "should install from a path when the package is a path and the source is nil" do
-        @new_resource = Chef::Resource::Package.new("/tmp/emacs-21.4-20.el5.i386.rpm")
+        @new_resource = Chef::Resource::Package.new("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
-        @new_resource.source.should == "/tmp/emacs-21.4-20.el5.i386.rpm"
-        @current_resource = Chef::Resource::Package.new("emacs")
+        @new_resource.source.should == "/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
+        @current_resource = Chef::Resource::Package.new("ImageMagick-c++")
         @provider.current_resource = @current_resource
         @provider.should_receive(:run_command_with_systems_locale).with({
-          :command => "rpm  -i /tmp/emacs-21.4-20.el5.i386.rpm"
+          :command => "rpm  -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
         })
-        @provider.install_package("/tmp/emacs-21.4-20.el5.i386.rpm", "21.4-20.el5")
+        @provider.install_package("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm", "6.5.4.7-7.el6_5")
       end
 
       it "should uprgrade from a path when the package is a path and the source is nil" do
-        @new_resource = Chef::Resource::Package.new("/tmp/emacs-21.4-20.el5.i386.rpm")
+        @new_resource = Chef::Resource::Package.new("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm")
         @provider = Chef::Provider::Package::Rpm.new(@new_resource, @run_context)
-        @new_resource.source.should == "/tmp/emacs-21.4-20.el5.i386.rpm"
-        @current_resource = Chef::Resource::Package.new("emacs")
+        @new_resource.source.should == "/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
+        @current_resource = Chef::Resource::Package.new("ImageMagick-c++")
         @current_resource.version("21.4-19.el5")
         @provider.current_resource = @current_resource
         @provider.should_receive(:run_command_with_systems_locale).with({
-          :command => "rpm  -U /tmp/emacs-21.4-20.el5.i386.rpm"
+          :command => "rpm  -U /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
         })
-        @provider.upgrade_package("/tmp/emacs-21.4-20.el5.i386.rpm", "21.4-20.el5")
+        @provider.upgrade_package("/tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm", "6.5.4.7-7.el6_5")
       end
 
       it "installs with custom options specified in the resource" do
         @provider.candidate_version = '11'
         @new_resource.options("--dbpath /var/lib/rpm")
         @provider.should_receive(:run_command_with_systems_locale).with({
-          :command => "rpm --dbpath /var/lib/rpm -i /tmp/emacs-21.4-20.el5.i386.rpm"
+          :command => "rpm --dbpath /var/lib/rpm -i /tmp/ImageMagick-c++-6.5.4.7-7.el6_5.x86_64.rpm"
         })
         @provider.install_package(@new_resource.name, @provider.candidate_version)
       end
@@ -142,9 +150,9 @@ describe Chef::Provider::Package::Rpm do
     describe "when removing the package" do
       it "should run rpm -e to remove the package" do
         @provider.should_receive(:run_command_with_systems_locale).with({
-          :command => "rpm  -e emacs-21.4-20.el5"
+          :command => "rpm  -e ImageMagick-c++-6.5.4.7-7.el6_5"
         })
-        @provider.remove_package("emacs", "21.4-20.el5")
+        @provider.remove_package("ImageMagick-c++", "6.5.4.7-7.el6_5")
       end
     end
   end

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

@@ -1619,25 +1619,32 @@ EOF
 
     it "should run yum-dump.py using the system python when next_refresh is for :all" do
       @yc.reload
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides$}, :timeout=>Chef::Config[:yum_timeout])
+      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should run yum-dump.py with the installed flag when next_refresh is for :installed" do
       @yc.reload_installed
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --installed$}, :timeout=>Chef::Config[:yum_timeout])
+      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --installed --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should run yum-dump.py with the all-provides flag when next_refresh is for :provides" do
       @yc.reload_provides
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --all-provides$}, :timeout=>Chef::Config[:yum_timeout])
+      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --all-provides --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 
     it "should pass extra_repo_control args to yum-dump.py" do
       @yc.enable_extra_repo_control("--enablerepo=foo --disablerepo=bar")
-      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar$}, :timeout=>Chef::Config[:yum_timeout])
+      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar --yum-lock-timeout 30$}, :timeout=>Chef::Config[:yum_timeout])
+      @yc.refresh
+    end
+
+    it "should pass extra_repo_control args and configured yum lock timeout to yum-dump.py" do
+      Chef::Config[:yum_lock_timeout] = 999
+      @yc.enable_extra_repo_control("--enablerepo=foo --disablerepo=bar")
+      @yc.should_receive(:shell_out!).with(%r{^/usr/bin/python .*/yum-dump.py --options --installed-provides --enablerepo=foo --disablerepo=bar --yum-lock-timeout 999$}, :timeout=>Chef::Config[:yum_timeout])
       @yc.refresh
     end
 

data/spec/unit/provider/registry_key_spec.rb

@@ -18,21 +18,14 @@
 
 require 'spec_helper'
 
-describe Chef::Provider::RegistryKey do
-
-  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(:testkey1) { 'HKLM\Software\Opscode\Testing' }
-
+shared_examples_for "a registry key" do
   before(:each) do
     @node = Chef::Node.new
     @events = Chef::EventDispatch::Dispatcher.new
     @run_context = Chef::RunContext.new(@node, {}, @events)
 
     @new_resource = Chef::Resource::RegistryKey.new("windows is fun", @run_context)
-    @new_resource.key testkey1
+    @new_resource.key keyname
     @new_resource.values( testval1 )
     @new_resource.recursive false
 
@@ -49,8 +42,8 @@ describe Chef::Provider::RegistryKey do
   describe "executing load_current_resource" do
     describe "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).with(testkey1).and_return(true)
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval2 )
+        @double_registry.should_receive(:key_exists?).with(keyname).and_return(true)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
         @provider.load_current_resource
       end
 
@@ -66,14 +59,14 @@ describe Chef::Provider::RegistryKey do
         @provider.current_resource.recursive.should == @new_resource.recursive
       end
 
-      it "should set the values of the current resource to the values it got from the registry" do
-        @provider.current_resource.values.should == [ testval2 ]
+      it "should set the unscrubbed values of the current resource to the values it got from the registry" do
+        @provider.current_resource.unscrubbed_values.should == [ testval2 ]
       end
     end
 
     describe "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).with(testkey1).and_return(false)
+        @double_registry.should_receive(:key_exists?).with(keyname).and_return(false)
         @provider.load_current_resource
       end
 
@@ -86,29 +79,29 @@ describe Chef::Provider::RegistryKey do
   describe "action_create" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(true)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "should do nothing if the key and the value both exist" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1 )
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
         @provider.action_create
       end
       it "should create the value if the key exists but the value does not" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval2 )
-        @double_registry.should_receive(:set_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
+        @double_registry.should_receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
       it "should set the value if the key exists but the data does not match" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1_wrong_data )
-        @double_registry.should_receive(:set_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_data )
+        @double_registry.should_receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
       it "should set the value if the key exists but the type does not match" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1_wrong_type )
-        @double_registry.should_receive(:set_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_type )
+        @double_registry.should_receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
@@ -116,8 +109,8 @@ describe Chef::Provider::RegistryKey do
     context "when the key exists and the values in the new resource are empty" do
       it "when a value is in the key, it should do nothing" do
         @provider.new_resource.values([])
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(true)
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1 )
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
         @double_registry.should_not_receive(:create_key)
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
@@ -125,8 +118,8 @@ describe Chef::Provider::RegistryKey do
       end
       it "when no value is in the key, it should do nothing" do
         @provider.new_resource.values([])
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(true)
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( nil )
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( nil )
         @double_registry.should_not_receive(:create_key)
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
@@ -135,11 +128,11 @@ describe Chef::Provider::RegistryKey do
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(false)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "should create the key and the value" do
-        @double_registry.should_receive(:create_key).with(testkey1, false)
-        @double_registry.should_receive(:set_value).with(testkey1, testval1)
+        @double_registry.should_receive(:create_key).with(keyname, false)
+        @double_registry.should_receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create
       end
@@ -147,8 +140,8 @@ describe Chef::Provider::RegistryKey do
     context "when the key does not exist and the values in the new resource are empty" do
       it "should create the key" do
         @new_resource.values([])
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(false)
-        @double_registry.should_receive(:create_key).with(testkey1, false)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
+        @double_registry.should_receive(:create_key).with(keyname, false)
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
         @provider.action_create
@@ -159,28 +152,28 @@ describe Chef::Provider::RegistryKey do
   describe "action_create_if_missing" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(true)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "should do nothing if the key and the value both exist" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1 )
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
       it "should create the value if the key exists but the value does not" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval2 )
-        @double_registry.should_receive(:set_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
+        @double_registry.should_receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
       it "should not set the value if the key exists but the data does not match" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1_wrong_data )
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_data )
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
       it "should not set the value if the key exists but the type does not match" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1_wrong_type )
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_type )
         @double_registry.should_not_receive(:set_value)
         @provider.load_current_resource
         @provider.action_create_if_missing
@@ -188,11 +181,11 @@ describe Chef::Provider::RegistryKey do
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(false)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "should create the key and the value" do
-        @double_registry.should_receive(:create_key).with(testkey1, false)
-        @double_registry.should_receive(:set_value).with(testkey1, testval1)
+        @double_registry.should_receive(:create_key).with(keyname, false)
+        @double_registry.should_receive(:set_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_create_if_missing
       end
@@ -202,28 +195,28 @@ describe Chef::Provider::RegistryKey do
   describe "action_delete" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(true)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "deletes the value when the value exists" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1 )
-        @double_registry.should_receive(:delete_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
+        @double_registry.should_receive(:delete_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_delete
       end
       it "deletes the value when the value exists, but the type is wrong" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1_wrong_type )
-        @double_registry.should_receive(:delete_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_type )
+        @double_registry.should_receive(:delete_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_delete
       end
       it "deletes the value when the value exists, but the data is wrong" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1_wrong_data )
-        @double_registry.should_receive(:delete_value).with(testkey1, testval1)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1_wrong_data )
+        @double_registry.should_receive(:delete_value).with(keyname, testval1)
         @provider.load_current_resource
         @provider.action_delete
       end
       it "does not delete the value when the value does not exist" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval2 )
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval2 )
         @double_registry.should_not_receive(:delete_value)
         @provider.load_current_resource
         @provider.action_delete
@@ -231,7 +224,7 @@ describe Chef::Provider::RegistryKey do
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(false)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "does nothing" do
         @double_registry.should_not_receive(:delete_value)
@@ -244,18 +237,18 @@ describe Chef::Provider::RegistryKey do
   describe "action_delete_key" do
     context "when the key exists" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(true)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(true)
       end
       it "deletes the key" do
-        @double_registry.should_receive(:get_values).with(testkey1).and_return( testval1 )
-        @double_registry.should_receive(:delete_key).with(testkey1, false)
+        @double_registry.should_receive(:get_values).with(keyname).and_return( testval1 )
+        @double_registry.should_receive(:delete_key).with(keyname, false)
         @provider.load_current_resource
         @provider.action_delete_key
       end
     end
     context "when the key does not exist" do
       before(:each) do
-        @double_registry.should_receive(:key_exists?).twice.with(testkey1).and_return(false)
+        @double_registry.should_receive(:key_exists?).twice.with(keyname).and_return(false)
       end
       it "does nothing" do
         @double_registry.should_not_receive(:delete_key)
@@ -267,3 +260,24 @@ describe Chef::Provider::RegistryKey do
 
 end
 
+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" } }
+
+    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 } }
+
+    it_should_behave_like "a registry key"
+  end
+end