chef 18.8.11 → 18.8.54

data/spec/unit/provider/directory_spec.rb

@@ -1,289 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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"
-require "tmpdir"
-
-describe Chef::Provider::Directory do
-  let(:tmp_dir) { Dir.mktmpdir }
-  let(:new_resource) { Chef::Resource::Directory.new(tmp_dir) }
-  let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:directory) { Chef::Provider::Directory.new(new_resource, run_context) }
-
-  describe "#load_current_resource" do
-    describe "scanning file security metadata"
-    describe "on unix", unix_only: true do
-      describe "when the directory exists" do
-        let(:dir_stat) { File::Stat.new(tmp_dir) }
-        let(:expected_uid) { dir_stat.uid }
-        let(:expected_gid) { dir_stat.gid }
-        let(:expected_mode) { "0%o" % ( dir_stat.mode & 007777 ) }
-        let(:expected_pwnam) { Etc.getpwuid(expected_uid).name }
-        let(:expected_grnam) { Etc.getgrgid(expected_gid).name }
-
-        it "describes the access mode as a String of octal integers" do
-          directory.load_current_resource
-          expect(directory.current_resource.mode).to eq(expected_mode)
-        end
-
-        it "when the new_resource.owner is numeric, describes the owner as a numeric uid" do
-          new_resource.owner(500)
-          directory.load_current_resource
-          expect(directory.current_resource.owner).to eql(expected_uid)
-        end
-
-        it "when the new_resource.group is numeric, describes the group as a numeric gid" do
-          new_resource.group(500)
-          directory.load_current_resource
-          expect(directory.current_resource.group).to eql(expected_gid)
-        end
-
-        it "when the new_resource.owner is a string, describes the owner as a string" do
-          new_resource.owner("foo")
-          directory.load_current_resource
-          expect(directory.current_resource.owner).to eql(expected_pwnam)
-        end
-
-        it "when the new_resource.group is a string, describes the group as a string" do
-          new_resource.group("bar")
-          directory.load_current_resource
-          expect(directory.current_resource.group).to eql(expected_grnam)
-        end
-      end
-    end
-
-    describe "on windows", windows_only: true do
-      describe "when the directory exists" do
-        it "the mode is always nil" do
-          directory.load_current_resource
-          expect(directory.current_resource.mode).to be nil
-        end
-
-        it "the owner is always nil" do
-          directory.load_current_resource
-          expect(directory.current_resource.owner).to be nil
-        end
-
-        it "the group is always nil" do
-          directory.load_current_resource
-          expect(directory.current_resource.group).to be nil
-        end
-
-        it "rights are always nil (incorrectly)" do
-          directory.load_current_resource
-          expect(directory.current_resource.rights).to be nil
-        end
-
-        it "inherits is always nil (incorrectly)" do
-          directory.load_current_resource
-          expect(directory.current_resource.inherits).to be nil
-        end
-      end
-    end
-
-    describe "when the directory does not exist" do
-      before do
-        FileUtils.rmdir tmp_dir
-      end
-
-      it "sets the mode, group and owner to nil" do
-        directory.load_current_resource
-        expect(directory.current_resource.mode).to eq(nil)
-        expect(directory.current_resource.group).to eq(nil)
-        expect(directory.current_resource.owner).to eq(nil)
-      end
-    end
-
-  end
-
-  describe "#define_resource_requirements" do
-    describe "on unix", unix_only: true do
-      it "raises an exception if the user does not exist" do
-        new_resource.owner("arglebargle_iv")
-        expect(Etc).to receive(:getpwnam).with("arglebargle_iv").and_raise(ArgumentError)
-        directory.action = :create
-        directory.load_current_resource
-        expect(directory.access_controls).to receive(:define_resource_requirements).and_call_original
-        directory.define_resource_requirements
-        expect { directory.process_resource_requirements }.to raise_error(ArgumentError)
-      end
-
-      it "raises an exception if the group does not exist" do
-        new_resource.group("arglebargle_iv")
-        expect(Etc).to receive(:getgrnam).with("arglebargle_iv").and_raise(ArgumentError)
-        directory.action = :create
-        directory.load_current_resource
-        expect(directory.access_controls).to receive(:define_resource_requirements).and_call_original
-        directory.define_resource_requirements
-        expect { directory.process_resource_requirements }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#run_action(:create)" do
-    describe "when the directory exists" do
-      it "does not create the directory" do
-        expect(Dir).not_to receive(:mkdir).with(new_resource.path)
-        directory.run_action(:create)
-      end
-
-      it "should not set the resource as updated" do
-        directory.run_action(:create)
-        expect(new_resource).not_to be_updated
-      end
-
-      context "in why run mode" do
-        before { Chef::Config[:why_run] = true }
-        after { Chef::Config[:why_run] = false }
-
-        it "does not modify new_resource" do
-          expect(directory).not_to receive(:load_resource_attributes_from_file).with(new_resource)
-          directory.run_action(:create)
-        end
-      end
-    end
-
-    describe "when the directory does not exist" do
-      before do
-        FileUtils.rmdir tmp_dir
-      end
-
-      it "creates the directory" do
-        directory.run_action(:create)
-        expect(File.exist?(tmp_dir)).to be true
-      end
-
-      it "sets the new resource as updated" do
-        directory.run_action(:create)
-        expect(new_resource).to be_updated
-      end
-    end
-
-    describe "when the parent directory does not exist" do
-      before do
-        new_resource.path "#{tmp_dir}/foobar"
-        FileUtils.rmdir tmp_dir
-      end
-
-      it "raises an exception when recursive is false" do
-        new_resource.recursive false
-        expect { directory.run_action(:create) }.to raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
-      end
-
-      it "creates the directories when recursive is true" do
-        new_resource.recursive true
-        directory.run_action(:create)
-        expect(new_resource).to be_updated
-        expect(File.exist?("#{tmp_dir}/foobar")).to be true
-      end
-
-      it "raises an exception when the parent directory is a file and recursive is true" do
-        FileUtils.touch tmp_dir
-        new_resource.recursive true
-        expect { directory.run_action(:create) }.to raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
-      end
-    end
-
-    describe "on macOS" do
-      before do
-        allow(ChefUtils).to receive(:macos?).and_return(true)
-        new_resource.path "/usr/bin/chef_test"
-        new_resource.recursive false
-        allow_any_instance_of(Chef::Provider::File).to receive(:do_selinux)
-      end
-
-      it "macOS cannot write to sip locations" do
-        allow(::File).to receive(:directory?).and_return(true)
-        allow(Chef::FileAccessControl).to receive(:writable?).and_return(false)
-        expect { directory.run_action(:create) }.to raise_error(Chef::Exceptions::InsufficientPermissions)
-      end
-
-      it "macOS can write to sip exclusions" do
-        new_resource.path "/usr/local/chef_test"
-        allow(::File).to receive(:directory?).and_return(true)
-        allow(Dir).to receive(:mkdir).and_return([true], [])
-        allow(Chef::FileAccessControl).to receive(:writable?).and_return(false)
-        directory.run_action(:create)
-        expect(new_resource).to be_updated
-      end
-    end
-  end
-
-  describe "#run_action(:delete)" do
-    describe "when the directory exists" do
-      it "deletes the directory" do
-        directory.run_action(:delete)
-        expect(File.exist?(tmp_dir)).to be false
-      end
-
-      it "sets the new resource as updated" do
-        directory.run_action(:delete)
-        expect(new_resource).to be_updated
-      end
-
-      it "does not use rm_rf which silently consumes errors" do
-        expect(FileUtils).not_to receive(:rm_rf)
-        expect(FileUtils).to receive(:rm_r)
-        # set recursive or FileUtils isn't used at all.
-        new_resource.recursive(true)
-        directory.run_action(:delete)
-        # reset back...
-        new_resource.recursive(false)
-      end
-    end
-
-    describe "when the directory does not exist" do
-      before do
-        FileUtils.rmdir tmp_dir
-      end
-
-      it "does not delete the directory" do
-        expect(Dir).not_to receive(:delete).with(new_resource.path)
-        directory.run_action(:delete)
-      end
-
-      it "sets the new resource as updated" do
-        directory.run_action(:delete)
-        expect(new_resource).not_to be_updated
-      end
-    end
-
-    describe "when the directory is not writable" do
-      before do
-        allow(Chef::FileAccessControl).to receive(:writable?).and_return(false)
-      end
-
-      it "cannot delete it and raises an exception" do
-        expect { directory.run_action(:delete) }.to raise_error(RuntimeError)
-      end
-    end
-
-    describe "when the target directory is a file" do
-      before do
-        FileUtils.rmdir tmp_dir
-        FileUtils.touch tmp_dir
-      end
-
-      it "cannot delete it and raises an exception" do
-        expect { directory.run_action(:delete) }.to raise_error(RuntimeError)
-      end
-    end
-  end
-end

data/spec/unit/provider/dsc_resource_spec.rb

@@ -1,313 +0,0 @@
-#
-# Author:: Jay Mundrawala (<jdm@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 "chef"
-require "spec_helper"
-
-describe Chef::Provider::DscResource do
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-  let(:resource) { Chef::Resource::DscResource.new("dscresource", run_context) }
-  let(:provider) do
-    Chef::Provider::DscResource.new(resource, run_context)
-  end
-
-  let(:node) do
-    node = Chef::Node.new
-    node.automatic[:languages][:powershell][:version] = "5.0.10586.0"
-    node
-  end
-
-  context "when PowerShell does not support Invoke-DscResource" do
-    let(:node) do
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = "4.0"
-      node
-    end
-    it "raises a ProviderNotFound exception" do
-      expect(provider).not_to receive(:meta_configuration)
-      expect { provider.run_action(:run) }.to raise_error(
-        Chef::Exceptions::ProviderNotFound, /5\.0\.10018\.0/
-      )
-    end
-  end
-
-  context "when PowerShell supports Invoke-DscResource" do
-
-    context "when RefreshMode is not set to Disabled" do
-      context "and the WMF 5 is a preview release" do
-        let(:node) do
-          node = Chef::Node.new
-          node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
-          node
-        end
-        it "raises an exception" do
-          expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(false)
-          expect { provider.run_action(:run) }.to raise_error(
-            Chef::Exceptions::ProviderNotFound, /Disabled/
-          )
-        end
-      end
-      context "and the WMF is 5 RTM or newer" do
-        let(:node) do
-          node = Chef::Node.new
-          node.automatic[:languages][:powershell][:version] = "5.0.10586.0"
-          node
-        end
-        it "does not raises an exception" do
-          expect(provider).to receive(:test_resource)
-          expect(provider).to receive(:set_resource)
-          expect(provider).to receive(:reboot_if_required)
-          expect { provider.run_action(:run) }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  context "when the LCM supports Invoke-DscResource" do
-    let(:node) do
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = "5.0.10018.0"
-      node
-    end
-    let(:resource_result) { double("PowerShell", result: { "InDesiredState" => true }, verbose: ["description"]) }
-    let(:store) { double("ResourceStore", find: resource_records) }
-    let(:resource_records) { [] }
-
-    before do
-      allow(Chef::Util::DSC::ResourceStore).to receive(:instance).and_return(store)
-      allow(provider).to receive(:powershell_exec!).and_return(resource_result)
-      allow(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
-    end
-
-    it "does not update the resource if it is up to date" do
-      expect(provider).to receive(:test_resource).and_return(true)
-      provider.run_action(:run)
-      expect(resource).not_to be_updated
-    end
-
-    it "converges the resource if it is not up to date" do
-      expect(provider).to receive(:test_resource).and_return(false)
-      expect(provider).to receive(:set_resource)
-      provider.run_action(:run)
-      expect(resource).to be_updated
-    end
-
-    it "flags the resource as reboot required when required" do
-      expect(provider).to receive(:test_resource).and_return(false)
-      expect(provider).to receive(:invoke_resource)
-        .and_return(double(result: { "RebootRequired" => true }))
-      expect(provider).to receive(:add_dsc_verbose_log)
-      expect(provider).to receive(:create_reboot_resource)
-      provider.run_action(:run)
-    end
-
-    it "does not flag the resource as reboot required when not required" do
-      expect(provider).to receive(:test_resource).and_return(false)
-      expect(provider).to receive(:invoke_resource)
-        .and_return(double(stdout: "", result: {}))
-      expect(provider).to receive(:add_dsc_verbose_log)
-      expect(provider).to_not receive(:create_reboot_resource)
-      provider.run_action(:run)
-    end
-
-    context "resource name cannot be found" do
-      let(:resource_records) { [] }
-
-      it "raises ResourceNotFound" do
-        expect { provider.run_action(:run) }.to raise_error(Chef::Exceptions::ResourceNotFound)
-      end
-    end
-
-    context "resource name is found" do
-      context "no module name for resource found" do
-        let(:resource_records) { [{}] }
-
-        it "returns the default dsc resource module" do
-          expect(provider).to receive(:powershell_exec!).with(/Module PSDesiredStateConfiguration /).and_return(resource_result)
-          provider.run_action(:run)
-        end
-      end
-
-      context "a module name for resource is found" do
-        let(:resource_records) { [{ "Module" => { "Name" => "ModuleName" } }] }
-
-        it "returns the default dsc resource module" do
-          expect(provider).to receive(:powershell_exec!).with(/Module ModuleName /).and_return(resource_result)
-          provider.run_action(:run)
-        end
-      end
-
-      context "multiple resource are found" do
-        let(:resource_records) do
-          [
-          { "Module" => { "Name" => "ModuleName1", "Version" => "1.0.0.0" } },
-          { "Module" => { "Name" => "ModuleName1", "Version" => "2.0.0.0" } },
-        ]
-        end
-
-        it "raises MultipleDscResourcesFound" do
-          expect { provider.run_action(:run) }.to raise_error(Chef::Exceptions::MultipleDscResourcesFound)
-        end
-      end
-    end
-  end
-
-  describe "define_resource_requirements" do
-    context "module usage is valid" do
-      before do
-        allow(provider).to receive(:module_usage_valid?).and_return(true)
-        allow(provider).to receive(:action_run)
-      end
-
-      [:run].each do |action|
-        context "action #{action}" do
-          it "does not raise the exception" do
-            expect { provider.run_action(action) }.not_to raise_error
-          end
-        end
-      end
-    end
-
-    context "module usage is invalid" do
-      before do
-        allow(provider).to receive(:module_usage_valid?).and_return(false)
-        allow(provider).to receive(:action_run)
-      end
-
-      [:run].each do |action|
-        context "action #{action}" do
-          it "raises the exception" do
-            expect { provider.run_action(action) }.to raise_error(
-              Chef::Exceptions::DSCModuleNameMissing
-            )
-          end
-        end
-      end
-    end
-  end
-
-  describe "module_usage_valid?" do
-    context "module_name and module_version both are not provided" do
-      before do
-        provider.instance_variable_set(:@module_name, nil)
-        provider.instance_variable_set(:@module_version, nil)
-      end
-
-      it "returns true" do
-        response = provider.send(:module_usage_valid?)
-        expect(response).to be == true
-      end
-    end
-
-    context "module_name and module_version both are provided" do
-      before do
-        provider.instance_variable_set(:@module_name, "my_module")
-        provider.instance_variable_set(:@module_version, "1.3")
-      end
-
-      it "returns true" do
-        response = provider.send(:module_usage_valid?)
-        expect(response).to be == true
-      end
-    end
-
-    context "module_name is given but module_version is not given" do
-      before do
-        provider.instance_variable_set(:@module_name, "my_module")
-        provider.instance_variable_set(:@module_version, nil)
-      end
-
-      it "returns true" do
-        response = provider.send(:module_usage_valid?)
-        expect(response).to be == true
-      end
-    end
-
-    context "module_name is not given but module_version is given" do
-      before do
-        provider.instance_variable_set(:@module_name, nil)
-        provider.instance_variable_set(:@module_version, "1.4.0.1")
-      end
-
-      it "returns false" do
-        response = provider.send(:module_usage_valid?)
-        expect(response).to be == false
-      end
-    end
-  end
-
-  describe "module_info_object" do
-    context "module_version is not given" do
-      before do
-        provider.instance_variable_set(:@module_version, nil)
-        allow(provider).to receive(:module_name).and_return("my_module")
-      end
-
-      it "returns only name of the module" do
-        response = provider.send(:module_info_object)
-        expect(response).to be == "my_module"
-      end
-    end
-
-    context "module_version is given" do
-      before do
-        provider.instance_variable_set(:@module_version, "1.3.1")
-        allow(provider).to receive(:module_name).and_return("my_module")
-      end
-
-      it "returns the module info object" do
-        response = provider.send(:module_info_object)
-        expect(response).to be == "@{ModuleName='my_module';ModuleVersion='1.3.1'}"
-      end
-    end
-  end
-
-  describe "invoke_resource" do
-    before(:each) do
-      allow(provider).to receive(:translate_type).and_return("my_properties")
-      provider.instance_variable_set(:@new_resource, double(
-        properties: "my_properties", resource: "my_resource", timeout: 123
-      ))
-    end
-
-    context "when module_version is not given" do
-      before do
-        allow(provider).to receive(:module_info_object).and_return("my_module")
-      end
-
-      it "invokes Invoke-DscResource command with module name" do
-        expect(provider).to receive(:powershell_exec!).with("Invoke-DscResource -Method my_method -Name my_resource -Property my_properties -Module my_module -Verbose").and_return(nil)
-        provider.send(:invoke_resource, "my_method")
-      end
-    end
-
-    context "when module_version is given" do
-      before do
-        allow(provider).to receive(:module_info_object).and_return(
-          "@{ModuleName='my_module';ModuleVersion='my_module_version'}"
-        )
-      end
-
-      it "invokes Invoke-DscResource command with module info object" do
-        expect(provider).to receive(:powershell_exec!).with("Invoke-DscResource -Method my_method -Name my_resource -Property my_properties -Module @{ModuleName='my_module';ModuleVersion='my_module_version'} -Verbose").and_return(nil)
-        provider.send(:invoke_resource, "my_method")
-      end
-    end
-  end
-end