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

data/lib/chef/knife/bootstrap/templates/archlinux-gems.erb

@@ -1,76 +0,0 @@
-bash -c '
-<%= "export http_proxy=\"#{knife_config[:bootstrap_proxy]}\"" if knife_config[:bootstrap_proxy] -%>
-
-if [ ! -f /usr/bin/chef-client ]; then
-  pacman -Syy
-  pacman -S --noconfirm ruby ntp base-devel
-  ntpdate -u pool.ntp.org
-  gem install ohai --no-user-install --no-document --verbose
-  gem install chef --no-user-install --no-document --verbose <%= Chef::VERSION %>
-fi
-
-mkdir -p /etc/chef
-
-<% if validation_key -%>
-cat > /etc/chef/validation.pem <<'EOP'
-<%= validation_key %>
-EOP
-chmod 0600 /etc/chef/validation.pem
-<% end -%>
-
-<% if encrypted_data_bag_secret -%>
-cat > /etc/chef/encrypted_data_bag_secret <<'EOP'
-<%= encrypted_data_bag_secret %>
-EOP
-chmod 0600 /etc/chef/encrypted_data_bag_secret
-<% end -%>
-
-<% unless trusted_certs.empty? -%>
-mkdir -p /etc/chef/trusted_certs
-<%= trusted_certs %>
-<% end -%>
-
-<%# Generate Ohai Hints -%>
-<% unless @chef_config[:knife][:hints].nil? || @chef_config[:knife][:hints].empty? -%>
-mkdir -p /etc/chef/ohai/hints
-
-<% @chef_config[:knife][:hints].each do |name, hash| -%>
-cat > /etc/chef/ohai/hints/<%= name %>.json <<'EOP'
-<%= Chef::JSONCompat.to_json(hash) %>
-EOP
-<% end -%>
-<% end -%>
-
-<% if client_pem -%>
-cat > /etc/chef/client.pem <<'EOP'
-<%= ::File.read(::File.expand_path(client_pem)) %>
-EOP
-chmod 0600 /etc/chef/client.pem
-<% end -%>
-
-cat > /etc/chef/client.rb <<'EOP'
-log_level        :info
-log_location     STDOUT
-chef_server_url  "<%= @chef_config[:chef_server_url] %>"
-validation_client_name "<%= @chef_config[:validation_client_name] %>"
-<% if @config[:chef_node_name] -%>
-node_name "<%= @config[:chef_node_name] %>"
-<% else -%>
-# Using default node name (fqdn)
-<% end -%>
-# ArchLinux follows the Filesystem Hierarchy Standard
-file_cache_path    "/var/cache/chef"
-file_backup_path   "/var/lib/chef/backup"
-pid_file           "/var/run/chef/client.pid"
-cache_options({ :path => "/var/cache/chef/checksums", :skip_expires => true})
-<% if knife_config[:bootstrap_proxy] %>
-http_proxy         "<%= knife_config[:bootstrap_proxy] %>"
-https_proxy        "<%= knife_config[:bootstrap_proxy] %>"
-<% end -%>
-EOP
-
-cat > /etc/chef/first-boot.json <<'EOP'
-<%= Chef::JSONCompat.to_json(first_boot) %>
-EOP
-
-<%= start_chef %>'

data/lib/chef/knife/bootstrap/templates/chef-aix.erb

@@ -1,72 +0,0 @@
-ksh -c '
-
-function exists {
-  if type $1 >/dev/null 2>&1
-  then
-    return 0
-  else
-    return 1
-  fi
-}
-
-if ! exists /usr/bin/chef-client; then
-  <% if @chef_config[:aix_package] -%>
-    # Read the download URL/location from knife.rb with option aix_package
-    rm -rf /tmp/chef_installer # ensure there no older pkg
-    echo "<%= @chef_config[:aix_package] %>"
-    perl -e '\''use LWP::Simple; getprint($ARGV[0]);'\'' <%= @chef_config[:aix_package] %> > /tmp/chef_installer
-    installp -aYF -d  /tmp/chef_installer chef
-  <% else -%>
-     echo ":aix_package location is not set in knife.rb"
-     exit
-  <% end -%>
-fi
-
-mkdir -p /etc/chef
-
-<% if client_pem -%>
-cat > /etc/chef/client.pem <<'EOP'
-<%= ::File.read(::File.expand_path(client_pem)) %>
-EOP
-chmod 0600 /etc/chef/client.pem
-<% end -%>
-
-<% if validation_key -%>
-cat > /etc/chef/validation.pem <<'EOP'
-<%= validation_key %>
-EOP
-chmod 0600 /etc/chef/validation.pem
-<% end -%>
-
-<% if encrypted_data_bag_secret -%>
-cat > /etc/chef/encrypted_data_bag_secret <<'EOP'
-<%= encrypted_data_bag_secret %>
-EOP
-chmod 0600 /etc/chef/encrypted_data_bag_secret
-<% end -%>
-
-<% unless trusted_certs.empty? -%>
-mkdir -p /etc/chef/trusted_certs
-<%= trusted_certs %>
-<% end -%>
-
-<%# Generate Ohai Hints -%>
-<% unless @chef_config[:knife][:hints].nil? || @chef_config[:knife][:hints].empty? -%>
-mkdir -p /etc/chef/ohai/hints
-
-<% @chef_config[:knife][:hints].each do |name, hash| -%>
-cat > /etc/chef/ohai/hints/<%= name %>.json <<'EOP'
-<%= Chef::JSONCompat.to_json(hash) %>
-EOP
-<% end -%>
-<% end -%>
-
-cat > /etc/chef/client.rb <<'EOP'
-<%= config_content %>
-EOP
-
-cat > /etc/chef/first-boot.json <<'EOP'
-<%= Chef::JSONCompat.to_json(first_boot) %>
-EOP
-
-<%= start_chef %>'

data/spec/unit/provider/powershell_spec.rb

@@ -1,80 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@opscode.com>)
-# Copyright:: Copyright (c) 2013 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::Provider::PowershellScript, "action_run" do
-
-  let(:powershell_version) { nil }
-  let(:node) {
-    node = Chef::Node.new
-    node.default["kernel"] = Hash.new
-    node.default["kernel"][:machine] = :x86_64.to_s
-    if ! powershell_version.nil?
-      node.default[:languages] = { :powershell => { :version => powershell_version } }
-    end
-    node
-  }
-
-  let(:provider) {
-    empty_events = Chef::EventDispatch::Dispatcher.new
-    run_context = Chef::RunContext.new(node, {}, empty_events)
-    new_resource = Chef::Resource::PowershellScript.new('run some powershell code', run_context)
-    Chef::Provider::PowershellScript.new(new_resource, run_context)
-  }
-
-  context 'when setting interpreter flags' do
-    it "should set the -File flag as the last flag" do
-      expect(provider.flags.split(' ').pop).to eq("-File")
-    end
-
-    let(:execution_policy_flag) do
-      execution_policy_index = 0
-      provider_flags = provider.flags.split(' ')
-      execution_policy_specified = false
-
-      provider_flags.find do | value |
-        execution_policy_index += 1
-        execution_policy_specified = value.downcase == '-ExecutionPolicy'.downcase
-      end
-
-      execution_policy = execution_policy_specified ? provider_flags[execution_policy_index] : nil
-    end
-
-    context 'when running with an unspecified PowerShell version' do
-      let(:powershell_version) { nil }
-      it "should set the -ExecutionPolicy flag to 'Unrestricted' by default" do
-        expect(execution_policy_flag.downcase).to eq('unrestricted'.downcase)
-      end
-    end
-
-    { '2.0' => 'Unrestricted',
-      '2.5' => 'Unrestricted',
-      '3.0' => 'Bypass',
-      '3.6' => 'Bypass',
-      '4.0' => 'Bypass',
-      '5.0' => 'Bypass' }.each do | version_policy |
-      let(:powershell_version) { version_policy[0].to_f }
-      context "when running PowerShell version #{version_policy[0]}" do
-        let(:powershell_version) { version_policy[0].to_f }
-        it "should set the -ExecutionPolicy flag to '#{version_policy[1]}'" do
-          expect(execution_policy_flag.downcase).to eq(version_policy[1].downcase)
-        end
-      end
-    end
-  end
-end

data/spec/unit/registry_helper_spec.rb

@@ -1,376 +0,0 @@
-#
-# 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::Provider::RegistryKey do
-
-  let(:value1) { { :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'}
-
-  before(:each) do
-    allow_any_instance_of(Chef::Win32::Registry).to receive(:machine_architecture).and_return(:x86_64)
-    @registry = Chef::Win32::Registry.new()
-
-    #Making the values for registry constants available on unix
-    Object.send(:remove_const, 'Win32') if defined?(Win32)
-    Win32 = Module.new
-    Win32::Registry = Class.new
-    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
-
-    Win32::Registry::Error = Class.new(RuntimeError)
-
-    @hive_mock = double("::Win32::Registry::HKEY_CURRENT_USER")
-    @reg_mock = double("reg")
-  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 "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(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      expect(@registry).to receive(:has_subkeys?).with(key_path).and_return(true)
-      expect(@registry).to receive(:get_subkeys).with(key_path).and_return([sub_key])
-      expect(@registry).to receive(:key_exists?).with(key_path+"\\"+sub_key).and_return(true)
-      expect(@registry).to receive(:get_hive_and_key).with(key_path+"\\"+sub_key).and_return([@hive_mock, key+"\\"+sub_key])
-      expect(@registry).to receive(:has_subkeys?).with(key_path+"\\"+sub_key).and_return(false)
-      expect(@registry).to receive(:delete_key_ex).twice
-      @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(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      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(:get_hive_and_key).with(key_path).and_return([@hive_mock, key])
-      expect(@registry).to receive(:has_subkeys?).with(key_path).and_return(false)
-      expect(@registry).to receive(:delete_key_ex)
-      @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