chef 12.4.3-universal-mingw32 → 12.5.1-universal-mingw32

data/spec/unit/provider_spec.rb

@@ -114,9 +114,7 @@ describe Chef::Provider do
   end
 
   it "does not re-load recipes when creating the temporary run context" do
-    # we actually want to test that RunContext#load is never called, but we
-    # can't stub all instances of an object with rspec's mocks. :/
-    allow(Chef::RunContext).to receive(:new).and_raise("not supposed to happen")
+    expect_any_instance_of(Chef::RunContext).not_to receive(:load)
     snitch = Proc.new {temporary_collection = @run_context.resource_collection}
     @provider.send(:recipe_eval, &snitch)
   end

data/spec/unit/recipe_spec.rb

@@ -154,8 +154,6 @@ describe Chef::Recipe do
           end
 
           it "selects the first one alphabetically" do
-            expect(Chef::Log).to receive(:warn).with("You declared a new resource TottenhamHotspur for resource football, but it comes alphabetically after Sounders and has the same filters ({:platform=>\"nbc_sports\"}), so it will not be used. Use override: true if you want to use it for football.")
-
             Sounders.provides :football, platform: "nbc_sports"
             TottenhamHotspur.provides :football, platform: "nbc_sports"
 
@@ -165,8 +163,6 @@ describe Chef::Recipe do
           end
 
           it "selects the first one alphabetically even if the declaration order is reversed" do
-            expect(Chef::Log).to receive(:warn).with("You are overriding football2 on {:platform=>\"nbc_sports\"} with Sounders: used to be TottenhamHotspur. Use override: true if this is what you intended.")
-
             TottenhamHotspur.provides :football2, platform: "nbc_sports"
             Sounders.provides :football2, platform: "nbc_sports"
 

data/spec/unit/resource/deploy_spec.rb

@@ -148,10 +148,16 @@ describe Chef::Resource::Deploy do
     expect(@resource.current_path).to eql("/my/deploy/dir/current")
   end
 
+  it "allows depth to be set via integer" do
+    expect(@resource.depth).to be_nil
+    @resource.depth 1
+    expect(@resource.depth).to eql(1)
+  end
+
   it "gives #depth as 5 if shallow clone is true, nil otherwise" do
     expect(@resource.depth).to be_nil
     @resource.shallow_clone true
-    expect(@resource.depth).to eql("5")
+    expect(@resource.depth).to eql(5)
   end
 
   it "aliases repo as repository" do

data/spec/unit/resource/dsc_script_spec.rb

@@ -70,6 +70,10 @@ describe Chef::Resource::DscScript do
       expect(dsc_test_resource.configuration_data_script).to eq(configuration_data_script)
     end
 
+    it "has the ps_credential helper method" do
+      expect(dsc_test_resource).to respond_to(:ps_credential)
+    end
+
     context "when calling imports" do
       let(:module_name)   { 'FooModule' }
       let(:module_name_b)   { 'BarModule' }

data/spec/unit/resource/file/verification_spec.rb

@@ -69,12 +69,40 @@ describe Chef::Resource::File::Verification do
     end
 
     context "with a verification command(String)" do
+      before(:each) do
+        allow(Chef::Log).to receive(:deprecation).and_return(nil)
+      end
+
+      def platform_specific_verify_command(variable_name)
+        if windows?
+          "if \"#{temp_path}\" == \"%{#{variable_name}}\" (exit 0) else (exit 1)"
+        else
+          "test #{temp_path} = %{#{variable_name}}"
+        end
+      end
+
       it "substitutes \%{file} with the path" do
-        test_command = if windows?
-                         "if \"#{temp_path}\" == \"%{file}\" (exit 0) else (exit 1)"
-                       else
-                         "test #{temp_path} = %{file}"
-                       end
+        test_command = platform_specific_verify_command('file')
+        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
+        expect(v.verify(temp_path)).to eq(true)
+      end
+
+      it "warns about deprecation when \%{file} is used" do
+        expect(Chef::Log).to receive(:deprecation).with(/%{file} is deprecated/, /verification_spec\.rb/)
+        test_command = platform_specific_verify_command('file')
+        Chef::Resource::File::Verification.new(parent_resource, test_command, {})
+          .verify(temp_path)
+      end
+
+      it "does not warn about deprecation when \%{file} is not used" do
+        expect(Chef::Log).to_not receive(:deprecation)
+        test_command = platform_specific_verify_command('path')
+        Chef::Resource::File::Verification.new(parent_resource, test_command, {})
+          .verify(temp_path)
+      end
+
+      it "substitutes \%{path} with the path" do
+        test_command = platform_specific_verify_command('path')
         v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
         expect(v.verify(temp_path)).to eq(true)
       end

data/spec/unit/resource/{powershell_spec.rb → powershell_script_spec.rb}

@@ -30,24 +30,28 @@ describe Chef::Resource::PowershellScript do
     run_context = Chef::RunContext.new(node, nil, nil)
 
     @resource = Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
-
   end
 
-  it "should create a new Chef::Resource::PowershellScript" do
+  it "creates a new Chef::Resource::PowershellScript" do
     expect(@resource).to be_a_kind_of(Chef::Resource::PowershellScript)
   end
 
-  it "should set convert_boolean_return to false by default" do
+  it "sets convert_boolean_return to false by default" do
     expect(@resource.convert_boolean_return).to eq(false)
   end
 
-  it "should return the value for convert_boolean_return that was set" do
+  it "returns the value for convert_boolean_return that was set" do
     @resource.convert_boolean_return true
     expect(@resource.convert_boolean_return).to eq(true)
     @resource.convert_boolean_return false
     expect(@resource.convert_boolean_return).to eq(false)
   end
 
+  it "raises an error when architecture is i386 on Windows Nano Server" do
+    allow(Chef::Platform).to receive(:windows_nano_server?).and_return(true)
+    expect{@resource.architecture(:i386)}.to raise_error(Chef::Exceptions::Win32ArchitectureIncorrect, "cannot execute script with requested architecture 'i386' on Windows Nano Server")
+  end
+
   context "when using guards" do
     let(:resource) { @resource }
     before(:each) do
@@ -62,32 +66,32 @@ describe Chef::Resource::PowershellScript do
       expect(inherited_difference).to eq([])
     end
 
-    it "should allow guard interpreter to be set to Chef::Resource::Script" do
+    it "allows guard interpreter to be set to Chef::Resource::Script" do
       resource.guard_interpreter(:script)
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
       resource.only_if("echo hi")
     end
 
-    it "should allow guard interpreter to be set to Chef::Resource::Bash derived from Chef::Resource::Script" do
+    it "allows guard interpreter to be set to Chef::Resource::Bash derived from Chef::Resource::Script" do
       resource.guard_interpreter(:bash)
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
       resource.only_if("echo hi")
     end
 
-    it "should allow guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
+    it "allows guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
       resource.guard_interpreter(:powershell_script)
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
       resource.only_if("echo hi")
     end
 
-    it "should enable convert_boolean_return by default for guards in the context of powershell_script when no guard params are specified" do
+    it "enables convert_boolean_return by default for guards in the context of powershell_script when no guard params are specified" do
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
         {:convert_boolean_return => true, :code => "$true"}).and_return(Proc.new {})
       resource.only_if("$true")
     end
 
-    it "should enable convert_boolean_return by default for guards in non-Chef::Resource::Script derived resources when no guard params are specified" do
+    it "enables convert_boolean_return by default for guards in non-Chef::Resource::Script derived resources when no guard params are specified" do
       node = Chef::Node.new
       run_context = Chef::RunContext.new(node, nil, nil)
       file_resource = Chef::Resource::File.new('idontexist', run_context)
@@ -98,21 +102,21 @@ describe Chef::Resource::PowershellScript do
       resource.only_if("$true")
     end
 
-    it "should enable convert_boolean_return by default for guards in the context of powershell_script when guard params are specified" do
+    it "enables convert_boolean_return by default for guards in the context of powershell_script when guard params are specified" do
       guard_parameters = {:cwd => '/etc/chef', :architecture => :x86_64}
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
         {:convert_boolean_return => true, :code => "$true"}.merge(guard_parameters)).and_return(Proc.new {})
       resource.only_if("$true", guard_parameters)
     end
 
-    it "should pass convert_boolean_return as true if it was specified as true in a guard parameter" do
+    it "passes convert_boolean_return as true if it was specified as true in a guard parameter" do
       guard_parameters = {:cwd => '/etc/chef', :convert_boolean_return => true, :architecture => :x86_64}
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
         {:convert_boolean_return => true, :code => "$true"}.merge(guard_parameters)).and_return(Proc.new {})
       resource.only_if("$true", guard_parameters)
     end
 
-    it "should pass convert_boolean_return as false if it was specified as true in a guard parameter" do
+    it "passes convert_boolean_return as false if it was specified as true in a guard parameter" do
       other_guard_parameters = {:cwd => '/etc/chef', :architecture => :x86_64}
       parameters_with_boolean_disabled = other_guard_parameters.merge({:convert_boolean_return => false, :code => "$true"})
       allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
@@ -127,6 +131,6 @@ describe Chef::Resource::PowershellScript do
     let(:resource_name) { :powershell_script }
     let(:interpreter_file_name) { 'powershell.exe' }
 
-    it_should_behave_like "a Windows script resource"
+    it_behaves_like "a Windows script resource"
   end
 end

data/spec/unit/resource/service_spec.rb

@@ -1,7 +1,7 @@
 #
 # Author:: AJ Christensen (<aj@hjksolutions.com>)
 # Author:: Tyler Cloke (<tyler@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright (c) 2008-2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -139,14 +139,14 @@ describe Chef::Resource::Service do
       expect { @resource.send(attrib, "poop") }.to raise_error(ArgumentError)
     end
 
-    it "should default all the feature support to false" do
-      support_hash = { :status => false, :restart => false, :reload=> false }
+    it "should default all the feature support to nil" do
+      support_hash = { :status => nil, :restart => nil, :reload=> nil }
       expect(@resource.supports).to eq(support_hash)
     end
 
     it "should allow you to set what features this resource supports as a array" do
       support_array = [ :status, :restart ]
-      support_hash = { :status => true, :restart => true, :reload => false }
+      support_hash = { :status => true, :restart => true, :reload => nil }
       @resource.supports(support_array)
       expect(@resource.supports).to eq(support_hash)
     end

data/spec/unit/resource/subversion_spec.rb

@@ -54,6 +54,10 @@ describe Chef::Resource::Subversion do
     expect(@svn.svn_arguments).to eq('--no-auth-cache')
   end
 
+  it "sets svn binary to nil by default" do
+    expect(@svn.svn_binary).to be_nil
+  end
+
   it "resets svn arguments to nil when given false in the setter" do
     @svn.svn_arguments(false)
     expect(@svn.svn_arguments).to be_nil

data/spec/unit/resource/yum_package_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright (c) 2008-2015 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -78,3 +78,12 @@ describe Chef::Resource::YumPackage, "allow_downgrade" do
     expect { @resource.allow_downgrade "monkey" }.to raise_error(ArgumentError)
   end
 end
+
+describe Chef::Resource::YumPackage, "yum_binary" do
+  let(:resource) { Chef::Resource::YumPackage.new("foo") }
+
+  it "should allow you to specify the yum_binary" do
+    resource.yum_binary "/usr/bin/yum-something"
+    expect(resource.yum_binary).to eql("/usr/bin/yum-something")
+  end
+end

data/spec/unit/resource_spec.rb

@@ -59,8 +59,8 @@ describe Chef::Resource do
   end
 
   describe "when declaring the identity attribute" do
-    it "has no identity attribute by default" do
-      expect(Chef::Resource.identity_attr).to be_nil
+    it "has :name as identity attribute by default" do
+      expect(Chef::Resource.identity_attr).to eq(:name)
     end
 
     it "sets an identity attribute" do

data/spec/unit/run_context/child_run_context_spec.rb

@@ -0,0 +1,133 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'support/lib/library_load_order'
+
+describe Chef::RunContext::ChildRunContext do
+  context "with a run context with stuff in it" do
+    let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "cookbooks")) }
+    let(:cookbook_collection) {
+      cl = Chef::CookbookLoader.new(chef_repo_path)
+      cl.load_cookbooks
+      Chef::CookbookCollection.new(cl)
+    }
+    let(:node) {
+      node = Chef::Node.new
+      node.run_list << "test" << "test::one" << "test::two"
+      node
+    }
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
+
+    context "and a child run context" do
+      let(:child) { run_context.create_child }
+
+      it "parent_run_context is set to the parent" do
+        expect(child.parent_run_context).to eq run_context
+      end
+
+      it "audits is not the same as the parent" do
+        expect(child.audits.object_id).not_to eq run_context.audits.object_id
+        child.audits['hi'] = 'lo'
+        expect(child.audits['hi']).to eq('lo')
+        expect(run_context.audits['hi']).not_to eq('lo')
+      end
+
+      it "resource_collection is not the same as the parent" do
+        expect(child.resource_collection.object_id).not_to eq run_context.resource_collection.object_id
+        f = Chef::Resource::File.new('hi', child)
+        child.resource_collection.insert(f)
+        expect(child.resource_collection).to include f
+        expect(run_context.resource_collection).not_to include f
+      end
+
+      it "immediate_notification_collection is not the same as the parent" do
+        expect(child.immediate_notification_collection.object_id).not_to eq run_context.immediate_notification_collection.object_id
+        src = Chef::Resource::File.new('hi', child)
+        dest = Chef::Resource::File.new('argh', child)
+        notification = Chef::Resource::Notification.new(dest, :create, src)
+        child.notifies_immediately(notification)
+        expect(child.immediate_notification_collection['file[hi]']).to eq([notification])
+        expect(run_context.immediate_notification_collection['file[hi]']).not_to eq([notification])
+      end
+
+      it "immediate_notifications is not the same as the parent" do
+        src = Chef::Resource::File.new('hi', child)
+        dest = Chef::Resource::File.new('argh', child)
+        notification = Chef::Resource::Notification.new(dest, :create, src)
+        child.notifies_immediately(notification)
+        expect(child.immediate_notifications(src)).to eq([notification])
+        expect(run_context.immediate_notifications(src)).not_to eq([notification])
+      end
+
+      it "delayed_notification_collection is not the same as the parent" do
+        expect(child.delayed_notification_collection.object_id).not_to eq run_context.delayed_notification_collection.object_id
+        src = Chef::Resource::File.new('hi', child)
+        dest = Chef::Resource::File.new('argh', child)
+        notification = Chef::Resource::Notification.new(dest, :create, src)
+        child.notifies_delayed(notification)
+        expect(child.delayed_notification_collection['file[hi]']).to eq([notification])
+        expect(run_context.delayed_notification_collection['file[hi]']).not_to eq([notification])
+      end
+
+      it "delayed_notifications is not the same as the parent" do
+        src = Chef::Resource::File.new('hi', child)
+        dest = Chef::Resource::File.new('argh', child)
+        notification = Chef::Resource::Notification.new(dest, :create, src)
+        child.notifies_delayed(notification)
+        expect(child.delayed_notifications(src)).to eq([notification])
+        expect(run_context.delayed_notifications(src)).not_to eq([notification])
+      end
+
+      it "create_child creates a child-of-child" do
+        c = child.create_child
+        expect(c.parent_run_context).to eq child
+      end
+
+      context "after load('include::default')" do
+        before do
+          run_list = Chef::RunList.new('include::default').expand('_default')
+          # TODO not sure why we had to do this to get everything to work ...
+          node.automatic_attrs[:recipes] = []
+          child.load(run_list)
+        end
+
+        it "load_recipe loads into the child" do
+          expect(child.resource_collection).to be_empty
+          child.load_recipe("include::includee")
+          expect(child.resource_collection).not_to be_empty
+        end
+
+        it "include_recipe loads into the child" do
+          expect(child.resource_collection).to be_empty
+          child.include_recipe("include::includee")
+          expect(child.resource_collection).not_to be_empty
+        end
+
+        it "load_recipe_file loads into the child" do
+          expect(child.resource_collection).to be_empty
+          child.load_recipe_file(File.expand_path("include/recipes/includee.rb", chef_repo_path))
+          expect(child.resource_collection).not_to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/unit/run_context_spec.rb

@@ -68,6 +68,9 @@ describe Chef::RunContext do
         "dependency2" => {
           "version" => "0.0.0",
         },
+        "include" => {
+          "version" => "0.0.0",
+        },
         "no-default-attr" => {
           "version" => "0.0.0",
         },
@@ -84,6 +87,10 @@ describe Chef::RunContext do
     )
   end
 
+  it "has a nil parent_run_context" do
+    expect(run_context.parent_run_context).to be_nil
+  end
+
   describe "loading cookbooks for a run list" do
     before do
 

data/spec/unit/run_list/versioned_recipe_list_spec.rb

@@ -187,4 +187,9 @@ describe Chef::RunList::VersionedRecipeList do
     end
   end
 
+  context "with duplicated names", :chef_gte_13_only do
+    it "should fail in Chef 13" do
+      expect(list).to_not respond_to(:with_duplicate_names)
+    end
+  end
 end

data/spec/unit/win32/registry_spec.rb

@@ -0,0 +1,394 @@
+#
+# Author:: Prajakta Purohit (prajakta@opscode.com)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Win32::Registry do
+  include_context "Win32"
+
+  let(:value1) { { :name => "one", :type => :string, :data => "1" } }
+  let(:value1_upcase_name) { {:name => "ONE", :type => :string, :data => "1"} }
+  let(:key_path) { 'HKCU\Software\OpscodeNumbers' }
+  let(:key) { 'Software\OpscodeNumbers' }
+  let(:key_parent) { 'Software' }
+  let(:key_to_delete) { 'OpscodeNumbers' }
+  let(:sub_key) {'OpscodePrimes'}
+  let(:missing_key_path) {'HKCU\Software'}
+  let(:registry) { Chef::Win32::Registry.new() }
+  let(:hive_mock) { double("::Win32::Registry::KHKEY_CURRENT_USER") }
+  let(:reg_mock) { double("reg") }
+
+  before(:all) do
+    Win32::Registry = Class.new
+    Win32::Registry::Error = Class.new(RuntimeError)
+  end
+
+  before(:each) do
+    allow_any_instance_of(Chef::Win32::Registry).to receive(:machine_architecture).and_return(:x86_64)
+    
+    #Making the values for registry constants available on unix
+    Win32::Registry::KEY_SET_VALUE = 0x0002
+    Win32::Registry::KEY_QUERY_VALUE = 0x0001
+    Win32::Registry::KEY_WRITE = 0x00020000 | 0x0002 | 0x0004
+    Win32::Registry::KEY_READ = 0x00020000 | 0x0001 | 0x0008 | 0x0010
+  end
+
+  after(:each) do
+    Win32::Registry.send(:remove_const, 'KEY_SET_VALUE') if defined?(Win32::Registry::KEY_SET_VALUE)
+    Win32::Registry.send(:remove_const, 'KEY_QUERY_VALUE') if defined?(Win32::Registry::KEY_QUERY_VALUE)
+    Win32::Registry.send(:remove_const, 'KEY_READ') if defined?(Win32::Registry::KEY_READ)
+    Win32::Registry.send(:remove_const, 'KEY_WRITE') if defined?(Win32::Registry::KEY_WRITE)
+  end
+
+  describe "get_values" do
+    it "gets all values for a key if the key exists" do
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:map)
+      registry.get_values(key_path)
+    end
+
+    it "throws an exception if key does not exist" do
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect{registry.get_values(key_path)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "set_value" do
+    it "does nothing if key and hive and value exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(registry).to receive(:data_exists?).with(key_path, value1).and_return(true)
+      registry.set_value(key_path, value1)
+    end
+    it "does nothing if case insensitive key and hive and value exist" do
+      expect(registry).to receive(:key_exists!).with(key_path.downcase).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path.downcase).and_return([hive_mock, key])
+      expect(registry).to receive(:value_exists?).with(key_path.downcase, value1).and_return(true)
+      expect(registry).to receive(:data_exists?).with(key_path.downcase, value1).and_return(true)
+      registry.set_value(key_path.downcase, value1)
+    end
+    it "does nothing if key and hive and value with a case insensitive name exist" do
+      expect(registry).to receive(:key_exists!).with(key_path.downcase).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path.downcase).and_return([hive_mock, key])
+      expect(registry).to receive(:value_exists?).with(key_path.downcase, value1_upcase_name).and_return(true)
+      expect(registry).to receive(:data_exists?).with(key_path.downcase, value1_upcase_name).and_return(true)
+      registry.set_value(key_path.downcase, value1_upcase_name)
+    end
+    it "updates value if key and hive and value exist, but data is different" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(registry).to receive(:data_exists?).with(key_path, value1).and_return(false)
+      expect(hive_mock).to receive(:open).with(key, Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(reg_mock).to receive(:write).with("one", 1, "1")
+      registry.set_value(key_path, value1)
+    end
+
+    it "creates value if the key exists and the value does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(reg_mock).to receive(:write).with("one", 1, "1")
+      registry.set_value(key_path, value1)
+    end
+
+    it "should raise an exception if the key does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {registry.set_value(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "delete_value" do
+    it "deletes value if value exists" do
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_SET_VALUE | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:delete_value).with("one").and_return(true)
+      registry.delete_value(key_path, value1)
+    end
+
+    it "raises an exception if the key does not exist" do
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      registry.delete_value(key_path, value1)
+    end
+
+    it "does nothing if the value does not exist" do
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      registry.delete_value(key_path, value1)
+    end
+  end
+
+  describe "create_key" do
+    it "creates key if intermediate keys are missing and recursive is set to true" do
+      expect(registry).to receive(:keys_missing?).with(key_path).and_return(true)
+      expect(registry).to receive(:create_missing).with(key_path)
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:create).with(key, ::Win32::Registry::KEY_WRITE | registry.registry_system_architecture)
+      registry.create_key(key_path, true)
+    end
+
+    it "raises an exception if intermediate keys are missing and recursive is set to false" do
+      expect(registry).to receive(:keys_missing?).with(key_path).and_return(true)
+      expect{registry.create_key(key_path, false)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+    end
+
+    it "does nothing if the key exists" do
+      expect(registry).to receive(:keys_missing?).with(key_path).and_return(true)
+      expect(registry).to receive(:create_missing).with(key_path)
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(true)
+      registry.create_key(key_path, true)
+    end
+
+    it "create key if intermediate keys not missing and recursive is set to false" do
+      expect(registry).to receive(:keys_missing?).with(key_path).and_return(false)
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:create).with(key, ::Win32::Registry::KEY_WRITE | registry.registry_system_architecture)
+      registry.create_key(key_path, false)
+    end
+
+    it "create key if intermediate keys not missing and recursive is set to true" do
+      expect(registry).to receive(:keys_missing?).with(key_path).and_return(false)
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:create).with(key, ::Win32::Registry::KEY_WRITE | registry.registry_system_architecture)
+      registry.create_key(key_path, true)
+    end
+  end
+
+  describe "delete_key", :windows_only do
+    it "deletes key if it has subkeys and recursive is set to true" do
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(true)
+      expect(registry).to receive(:has_subkeys?).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key_parent, ::Win32::Registry::KEY_WRITE | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:delete_key).with(key_to_delete, true).and_return(true)
+      registry.delete_key(key_path, true)
+    end
+
+    it "raises an exception if it has subkeys but recursive is set to false" do
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(true)
+      expect(registry).to receive(:has_subkeys?).with(key_path).and_return(true)
+      expect{registry.delete_key(key_path, false)}.to raise_error(Chef::Exceptions::Win32RegNoRecursive)
+    end
+
+    it "deletes key if the key exists and has no subkeys" do
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(true)
+      expect(registry).to receive(:has_subkeys?).with(key_path).and_return(false)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key_parent, ::Win32::Registry::KEY_WRITE | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:delete_key).with(key_to_delete, true).and_return(true)
+      registry.delete_key(key_path, true)
+    end
+  end
+
+  describe "key_exists?" do
+    it "returns true if key_exists" do
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(registry.key_exists?(key_path)).to eq(true)
+    end
+
+    it "returns false if key does not exist" do
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_raise(::Win32::Registry::Error)
+      expect(registry.key_exists?(key_path)).to eq(false)
+    end
+  end
+
+  describe "key_exists!" do
+    it "throws an exception if the key_parent does not exist" do
+      expect(registry).to receive(:key_exists?).with(key_path).and_return(false)
+      expect{registry.key_exists!(key_path)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "hive_exists?" do
+    it "returns true if the hive exists" do
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      registry.hive_exists?(key_path) == true
+    end
+
+    it "returns false if the hive does not exist" do
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_raise(Chef::Exceptions::Win32RegHiveMissing)
+      registry.hive_exists?(key_path) == false
+    end
+  end
+
+  describe "has_subkeys?" do
+    it "returns true if the key has subkeys" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:each_key).and_yield(key)
+      registry.has_subkeys?(key_path) == true
+    end
+
+    it "returns false if the key does not have subkeys" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:each_key).and_return(no_args())
+      expect(registry.has_subkeys?(key_path)).to eq(false)
+    end
+
+    it "throws an exception if the key does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {registry.set_value(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+  end
+
+  describe "get_subkeys" do
+    it "returns the subkeys if they exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:each_key).and_yield(sub_key)
+      registry.get_subkeys(key_path)
+    end
+  end
+
+  describe "value_exists?" do
+    it "throws an exception if the key does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {registry.value_exists?(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+
+    it "returns true if the value exists" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:any?).and_yield("one")
+      registry.value_exists?(key_path, value1) == true
+    end
+
+    it "returns false if the value does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:any?).and_yield(no_args())
+      registry.value_exists?(key_path, value1) == false
+    end
+  end
+
+  describe "data_exists?" do
+    it "throws an exception if the key does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_raise(Chef::Exceptions::Win32RegKeyMissing)
+      expect {registry.data_exists?(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegKeyMissing)
+    end
+
+    it "returns true if the data exists" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(reg_mock).to receive(:each).with(no_args()).and_yield("one", 1, "1")
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(registry.data_exists?(key_path, value1)).to eq(true)
+    end
+
+    it "returns false if the data does not exist" do
+      expect(registry).to receive(:key_exists!).with(key_path).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(reg_mock).to receive(:each).with(no_args()).and_yield("one", 1, "2")
+      expect(registry.data_exists?(key_path, value1)).to eq(false)
+    end
+  end
+
+  describe "value_exists!" do
+    it "does nothing if the value exists" do
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(true)
+      registry.value_exists!(key_path, value1)
+    end
+
+    it "throws an exception if the value does not exist" do
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect{registry.value_exists!(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegValueMissing)
+    end
+  end
+
+  describe "data_exists!" do
+    it "does nothing if the data exists" do
+      expect(registry).to receive(:data_exists?).with(key_path, value1).and_return(true)
+      registry.data_exists!(key_path, value1)
+    end
+
+    it "throws an exception if the data does not exist" do
+      expect(registry).to receive(:data_exists?).with(key_path, value1).and_return(false)
+      expect{registry.data_exists!(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegDataMissing)
+    end
+  end
+
+  describe "type_matches?" do
+    it "returns true if type matches" do
+      expect(registry).to receive(:value_exists!).with(key_path, value1).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(registry).to receive(:get_type_from_name).with(:string).and_return(1)
+      expect(reg_mock).to receive(:each).and_yield("one", 1)
+      expect(registry.type_matches?(key_path, value1)).to eq(true)
+    end
+
+    it "returns false if type does not match" do
+      expect(registry).to receive(:value_exists!).with(key_path, value1).and_return(true)
+      expect(registry).to receive(:get_hive_and_key).with(key_path).and_return([hive_mock, key])
+      expect(hive_mock).to receive(:open).with(key, ::Win32::Registry::KEY_READ | registry.registry_system_architecture).and_yield(reg_mock)
+      expect(reg_mock).to receive(:each).and_yield("two", 2)
+      expect(registry.type_matches?(key_path, value1)).to eq(false)
+    end
+
+    it "throws an exception if value does not exist" do
+      expect(registry).to receive(:value_exists?).with(key_path, value1).and_return(false)
+      expect{registry.type_matches?(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegValueMissing)
+    end
+  end
+
+  describe "type_matches!" do
+    it "does nothing if the type_matches" do
+      expect(registry).to receive(:type_matches?).with(key_path, value1).and_return(true)
+      registry.type_matches!(key_path, value1)
+    end
+
+    it "throws an exception if the type does not match" do
+      expect(registry).to receive(:type_matches?).with(key_path, value1).and_return(false)
+      expect{registry.type_matches!(key_path, value1)}.to raise_error(Chef::Exceptions::Win32RegTypesMismatch)
+    end
+  end
+
+  describe "keys_missing?" do
+    it "returns true if the keys are missing" do
+      expect(registry).to receive(:key_exists?).with(missing_key_path).and_return(false)
+      expect(registry.keys_missing?(key_path)).to eq(true)
+    end
+
+    it "returns false if no keys in the path are missing" do
+      expect(registry).to receive(:key_exists?).with(missing_key_path).and_return(true)
+      expect(registry.keys_missing?(key_path)).to eq(false)
+    end
+  end
+end