chef 18.7.10 → 18.8.46

data/spec/unit/win32/registry_spec.rb

@@ -1,394 +0,0 @@
-#
-# Author:: Prajakta Purohit (prajakta@chef.io)
-# Copyright:: Copyright (c) Chef Software 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::HKEY_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

data/spec/unit/win32/security_spec.rb

@@ -1,136 +0,0 @@
-#
-# Author:: Aliasgar Batterywala (aliasgar.batterywala@msystechnologies.com)
-# Copyright:: Copyright (c) Chef Software 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"
-if ChefUtils.windows?
-  require "chef/win32/error"
-  require "chef/win32/security"
-  require "chef/win32/api/error"
-end
-
-describe "Chef::Win32::Security", :windows_only do
-  describe "self.get_named_security_info" do
-    context "when HR result is ERROR_SUCCESS" do
-      it "does not raise the exception" do
-        expect(Chef::ReservedNames::Win32::Security).to receive(:GetNamedSecurityInfoW).and_return(
-          Chef::ReservedNames::Win32::API::Error::ERROR_SUCCESS
-        )
-        expect { Chef::ReservedNames::Win32::Security.get_named_security_info "/temp_path" }.to_not raise_error
-      end
-    end
-
-    context "when HR result is not ERROR_SUCCESS and not ERROR_USER_NOT_FOUND" do
-      it "raises Win32APIError exception" do
-        expect(Chef::ReservedNames::Win32::Security).to receive(:GetNamedSecurityInfoW).and_return(
-          Chef::ReservedNames::Win32::API::Error::ERROR_INVALID_ACCESS
-        )
-        expect { Chef::ReservedNames::Win32::Security.get_named_security_info "/temp_path" }.to raise_error Chef::Exceptions::Win32APIError
-      end
-    end
-  end
-
-  describe "self.set_named_security_info" do
-    context "when HR result is ERROR_SUCCESS" do
-      it "does not raise the exception" do
-        expect(Chef::ReservedNames::Win32::Security).to receive(:SetNamedSecurityInfoW).and_return(
-          Chef::ReservedNames::Win32::API::Error::ERROR_SUCCESS
-        )
-        expect { Chef::ReservedNames::Win32::Security.set_named_security_info "/temp_path", :SE_FILE_OBJECT, {} }.to_not raise_error
-      end
-    end
-
-    context "when HR result is not ERROR_SUCCESS but it is ERROR_USER_NOT_FOUND" do
-      it "raises UserIDNotFound exception" do
-        expect(Chef::ReservedNames::Win32::Security).to receive(:SetNamedSecurityInfoW).and_return(
-          Chef::ReservedNames::Win32::API::Error::ERROR_USER_NOT_FOUND
-        )
-        expect { Chef::ReservedNames::Win32::Security.set_named_security_info "/temp_path", :SE_FILE_OBJECT, {} }.to raise_error Chef::Exceptions::UserIDNotFound
-      end
-    end
-  end
-
-  describe "self.has_admin_privileges?" do
-    context "when the user doesn't have admin privileges" do
-      it "returns false" do
-        allow(Chef::ReservedNames::Win32::Security).to receive(:open_current_process_token).and_raise("Access is denied.")
-        expect(Chef::ReservedNames::Win32::Security.has_admin_privileges?).to be false
-      end
-    end
-
-    context "when open_current_process_token fails with some other error than `Access is Denied`" do
-      it "raises error" do
-        allow(Chef::ReservedNames::Win32::Security).to receive(:open_current_process_token).and_raise("boom")
-        expect { Chef::ReservedNames::Win32::Security.has_admin_privileges? }.to raise_error(Chef::Exceptions::Win32APIError)
-      end
-    end
-
-    context "when the user has admin privileges" do
-      it "returns true" do
-        token = double(:process_token)
-        allow(token).to receive_message_chain(:handle, :handle)
-
-        allow(Chef::ReservedNames::Win32::Security).to receive(:open_current_process_token).and_return(token)
-        allow(Chef::ReservedNames::Win32::Security).to receive(:get_token_information_elevation_type)
-        allow(Chef::ReservedNames::Win32::Security).to receive(:GetTokenInformation).and_return(true)
-        allow_any_instance_of(FFI::Buffer).to receive(:read_ulong).and_return(1)
-        expect(Chef::ReservedNames::Win32::Security.has_admin_privileges?).to be true
-      end
-    end
-  end
-
-  describe "self.get_token_information_elevation_type" do
-    let(:token_rights) { Chef::ReservedNames::Win32::Security::TOKEN_READ }
-
-    let(:token) do
-      Chef::ReservedNames::Win32::Security.open_process_token(
-        Chef::ReservedNames::Win32::Process.get_current_process,
-        token_rights
-      )
-    end
-
-    it "raises error if GetTokenInformation fails" do
-      allow(Chef::ReservedNames::Win32::Security).to receive(:GetTokenInformation).and_return(false)
-      expect { Chef::ReservedNames::Win32::Security.get_token_information_elevation_type(token) }.to raise_error(Chef::Exceptions::Win32APIError)
-    end
-  end
-
-  describe "self.lookup_account_name" do
-    let(:security_class) { Chef::ReservedNames::Win32::Security }
-
-    context "when FFI::LastError.error result is ERROR_INSUFFICIENT_BUFFER" do
-      it "does not raise the exception" do
-        expect(FFI::LastError).to receive(:error).and_return(122)
-        expect { security_class.lookup_account_name "system" }.to_not raise_error
-      end
-    end
-
-    context "when operation completed successfully and FFI::LastError.error result is NO_ERROR" do
-      it "does not raise the exception" do
-        expect(FFI::LastError).to receive(:error).and_return(0)
-        expect { security_class.lookup_account_name "system" }.to_not raise_error
-      end
-    end
-
-    context "when FFI::LastError.error result is not ERROR_INSUFFICIENT_BUFFER and not NO_ERROR" do
-      it "raises Chef::ReservedNames::Win32::Error.raise! exception" do
-        expect(FFI::LastError).to receive(:error).and_return(123).at_least(:once)
-        expect { security_class.lookup_account_name "system" }.to raise_error(Chef::Exceptions::Win32APIError)
-      end
-    end
-  end
-end

data/tasks/rspec.rb

@@ -1,87 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software 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 "rubygems"
-require "rake"
-
-begin
-  require "rspec/core/rake_task"
-
-  desc "Run specs for Chef's Gem Components"
-  task :component_specs do
-    %w{chef-utils chef-config knife}.each do |gem|
-      Dir.chdir(gem) do
-        puts "--- Running #{gem} specs"
-        Bundler.with_unbundled_env do
-          puts "Executing tests in #{Dir.pwd}:"
-          sh("bundle config set --local path 'vendor/bundle'")
-          sh("bundle install --jobs=3 --retry=3")
-          sh("bundle exec rake spec")
-        end
-      end
-    end
-  end
-
-  task default: :spec
-
-  task spec: :component_specs
-
-  desc "Run all chef specs in spec directory"
-  RSpec::Core::RakeTask.new(:spec) do |t|
-    t.verbose = false
-    t.rspec_opts = %w{--profile}
-    t.pattern = FileList["spec/**/*_spec.rb"]
-  end
-
-  namespace :spec do
-    desc "Run all chef specs in spec directory"
-    RSpec::Core::RakeTask.new(:all) do |t|
-      t.verbose = false
-      t.rspec_opts = %w{--profile}
-      t.pattern = FileList["spec/**/*_spec.rb"]
-    end
-
-    desc "Print Specdoc for all specs"
-    RSpec::Core::RakeTask.new(:doc) do |t|
-      t.verbose = false
-      t.rspec_opts = %w{--format specdoc --dry-run --profile}
-      t.pattern = FileList["spec/**/*_spec.rb"]
-    end
-
-    desc "Run chef's node and role unit specs with activesupport loaded"
-    RSpec::Core::RakeTask.new(:activesupport) do |t|
-      t.verbose = false
-      t.rspec_opts = %w{--require active_support/core_ext --profile}
-      # Only node_spec and role_spec specifically have issues, target those tests
-      t.pattern = FileList["spec/unit/node_spec.rb", "spec/unit/role_spec.rb"]
-    end
-
-    %i{unit functional integration stress}.each do |sub|
-      desc "Run the chef specs under spec/#{sub}"
-      RSpec::Core::RakeTask.new(sub) do |t|
-        puts "--- Running chef #{sub} specs"
-        t.verbose = false
-        t.rspec_opts = %w{--profile --format doc}
-        t.pattern = FileList["spec/#{sub}/**/*_spec.rb"]
-      end
-    end
-  end
-rescue LoadError
-  STDERR.puts "\n*** RSpec not available. (sudo) gem install rspec to run unit tests. ***\n\n"
-end