chef 16.1.16 → 16.18.30

data/spec/unit/resource/windows_feature_powershell_spec.rb

@@ -22,6 +22,7 @@ describe Chef::Resource::WindowsFeaturePowershell do
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:resource) { Chef::Resource::WindowsFeaturePowershell.new(%w{SNMP DHCP}, run_context) }
+  let(:provider) { resource.provider_for_action(:install) }
 
   it "sets resource name as :windows_feature_powershell" do
     expect(resource.resource_name).to eql(:windows_feature_powershell)
@@ -35,10 +36,6 @@ describe Chef::Resource::WindowsFeaturePowershell do
     expect(resource.feature_name).to eql(%w{snmp dhcp})
   end
 
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
   it "supports :delete, :install, :remove actions" do
     expect { resource.action :delete }.not_to raise_error
     expect { resource.action :install }.not_to raise_error
@@ -54,4 +51,33 @@ describe Chef::Resource::WindowsFeaturePowershell do
     resource.feature_name "SNMP"
     expect(resource.feature_name).to eql(["snmp"])
   end
+
+  it "install a single feature" do
+    resource.feature_name "snmp"
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "install multi feature" do
+    resource.feature_name "SNMP, DHCP"
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "does not attempt to install features that have been removed" do
+    node.default["powershell_features_cache"] ||= {}
+    node.default["powershell_features_cache"]["disabled"] = ["dhcp"]
+    node.default["powershell_features_cache"]["removed"] = ["snmp"]
+    resource.feature_name "dhcp, snmp"
+
+    expect(provider.features_to_install).to eq(["dhcp"])
+  end
+
+  it "attempts to install features that have been removed when source is set" do
+    node.default["powershell_features_cache"] ||= {}
+    node.default["powershell_features_cache"]["disabled"] = ["dhcp"]
+    node.default["powershell_features_cache"]["removed"] = ["snmp"]
+    resource.feature_name "dhcp, snmp"
+    resource.source 'D:\\sources\\sxs'
+
+    expect(provider.features_to_install).to eq(%w{dhcp snmp})
+  end
 end

data/spec/unit/resource/windows_firewall_profile_spec.rb

@@ -0,0 +1,77 @@
+#
+# 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::Resource::WindowsFirewallProfile do
+  let(:resource) { Chef::Resource::WindowsFirewallProfile.new("fakey_fakerton") }
+
+  it "sets resource name as :windows_firewall_profile" do
+    expect(resource.resource_name).to eql(:windows_firewall_profile)
+  end
+
+  %w{ Domain Private Public }.each do |this_profile|
+    it "The profile accepts values for the \"#{this_profile}\" Profile" do
+      expect { resource.profile this_profile }.not_to raise_error
+    end
+  end
+
+  it "the profile property does not accept bad profile names" do
+    expect { resource.profile "Special" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "the resource's default_inbound_action property only strings Block, Allow, or NotConfigured" do
+    expect { resource.default_inbound_action "AllowSome" }.to raise_error(ArgumentError)
+    expect { resource.default_inbound_action "Block" }.not_to raise_error
+  end
+  it "the resource's default_outbound_action property only accepts strings Block, Allow, or NotConfigured" do
+    expect { resource.default_outbound_action "BlockMost" }.to raise_error(ArgumentError)
+    expect { resource.default_outbound_action "Allow" }.not_to raise_error
+  end
+  it "the resource's allow_inbound_rules property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_inbound_rules "Yes" }.to raise_error(ArgumentError)
+    expect { resource.allow_inbound_rules true }.not_to raise_error
+  end
+  it "the resource's allow_local_firewall_rules property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_local_firewall_rules "No" }.to raise_error(ArgumentError)
+    expect { resource.allow_local_firewall_rules false }.not_to raise_error
+  end
+  it "the resource's allow_local_ipsec_rules property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_local_ipsec_rules "Yes" }.to raise_error(ArgumentError)
+    expect { resource.allow_local_ipsec_rules true }.not_to raise_error
+  end
+  it "the resource's allow_user_apps property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_user_apps "No" }.to raise_error(ArgumentError)
+    expect { resource.allow_user_apps false }.not_to raise_error
+  end
+  it "the resource's allow_user_ports property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_user_ports "Nope" }.to raise_error(ArgumentError)
+    expect { resource.allow_user_ports "NotConfigured" }.not_to raise_error
+  end
+  it "the resource's allow_unicast_response property only accepts strings true, false, or NotConfigured" do
+    expect { resource.allow_unicast_response "True" }.to raise_error(ArgumentError)
+    expect { resource.allow_unicast_response true }.not_to raise_error
+  end
+  it "the resource's display_notification property only accepts strings true, false, or NotConfigured" do
+    expect { resource.display_notification "False" }.to raise_error(ArgumentError)
+    expect { resource.display_notification false }.not_to raise_error
+  end
+
+  it "sets the default action as :configure" do
+    expect(resource.action).to eql([:enable])
+  end
+end

data/spec/unit/resource/windows_package_spec.rb

@@ -58,6 +58,7 @@ describe Chef::Resource::WindowsPackage, "initialize" do
     expect { resource.installer_type :msi }.not_to raise_error
     expect { resource.installer_type :nsis }.not_to raise_error
     expect { resource.installer_type :wise }.not_to raise_error
+    expect { resource.installer_type :something_else_entirely }.to raise_error(Chef::Exceptions::ValidationFailed)
     expect { resource.installer_type "msi" }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 

data/spec/unit/resource/windows_task_spec.rb

@@ -144,7 +144,7 @@ describe Chef::Resource::WindowsTask, :windows_only do
       resource.frequency :once
       resource.random_delay "20"
       resource.start_time "15:00"
-      expect { resource.after_created }.to_not raise_error(ArgumentError, "`random_delay` property is supported only for frequency :once, :minute, :hourly, :daily, :weekly and :monthly")
+      expect { resource.after_created }.to_not raise_error
     end
 
     it "raises error for invalid random_delay" do

data/spec/unit/resource/windows_uac_spec.rb

@@ -26,7 +26,7 @@ describe Chef::Resource::WindowsUac do
 
   %i{no_prompt secure_prompt_for_creds secure_prompt_for_consent prompt_for_creds prompt_for_consent prompt_for_consent_non_windows_binaries}.each do |val|
     it "the consent_behavior_admins property accepts :#{val}" do
-      expect { resource.consent_behavior_admins val }.not_to raise_error(ArgumentError)
+      expect { resource.consent_behavior_admins val }.not_to raise_error
     end
   end
 
@@ -36,7 +36,7 @@ describe Chef::Resource::WindowsUac do
 
   %i{auto_deny secure_prompt_for_creds prompt_for_creds}.each do |val|
     it "the consent_behavior_users property accepts :#{val}" do
-      expect { resource.consent_behavior_users val }.not_to raise_error(ArgumentError)
+      expect { resource.consent_behavior_users val }.not_to raise_error
     end
   end
 
@@ -44,7 +44,7 @@ describe Chef::Resource::WindowsUac do
     expect { resource.consent_behavior_users :bogus }.to raise_error(ArgumentError)
   end
 
-  it "sets the default action as :create" do
+  it "sets the default action as :configure" do
     expect(resource.action).to eql([:configure])
   end
 end

data/spec/unit/resource/windows_user_privilege_spec.rb

@@ -0,0 +1,55 @@
+#
+# 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::Resource::WindowsUserPrivilege do
+  let(:resource) { Chef::Resource::WindowsUserPrivilege.new("fakey_fakerton") }
+
+  it "sets resource name as :windows_user_privilege" do
+    expect(resource.resource_name).to eql(:windows_user_privilege)
+  end
+
+  it "the principal property is the name_property" do
+    expect(resource.principal).to eql("fakey_fakerton")
+  end
+
+  it "the users property coerces to an array" do
+    resource.users "Administrator"
+    expect(resource.users).to eql(["Administrator"])
+  end
+
+  it "the privilege property coerces to an array" do
+    resource.privilege "SeDenyRemoteInteractiveLogonRight"
+    expect(resource.privilege).to eql(["SeDenyRemoteInteractiveLogonRight"])
+  end
+
+  it "the privilege property validates inputs against the allowed list of privs" do
+    expect { resource.privilege "invalidPriv" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "sets the default action as :add" do
+    expect(resource.action).to eql([:add])
+  end
+
+  it "supports :add, :set, :clear, :remove actions" do
+    expect { resource.action :add }.not_to raise_error
+    expect { resource.action :set }.not_to raise_error
+    expect { resource.action :clear }.not_to raise_error
+    expect { resource.action :remove }.not_to raise_error
+  end
+end

data/spec/unit/resource/yum_repository_spec.rb

@@ -73,52 +73,52 @@ describe Chef::Resource::YumRepository do
   end
 
   it "the timeout property expects numeric Strings" do
-    expect { resource.timeout "123" }.not_to raise_error(ArgumentError)
+    expect { resource.timeout "123" }.not_to raise_error
     expect { resource.timeout "123foo" }.to raise_error(ArgumentError)
   end
 
   it "the priority property expects numeric Strings from '1' to '99'" do
-    expect { resource.priority "99" }.not_to raise_error(ArgumentError)
-    expect { resource.priority "1" }.not_to raise_error(ArgumentError)
+    expect { resource.priority "99" }.not_to raise_error
+    expect { resource.priority "1" }.not_to raise_error
     expect { resource.priority "100" }.to raise_error(ArgumentError)
     expect { resource.priority "0" }.to raise_error(ArgumentError)
   end
 
   it "the failovermethod property accepts 'priority' or 'roundrobin'" do
-    expect { resource.failovermethod "priority" }.not_to raise_error(ArgumentError)
-    expect { resource.failovermethod "roundrobin" }.not_to raise_error(ArgumentError)
+    expect { resource.failovermethod "priority" }.not_to raise_error
+    expect { resource.failovermethod "roundrobin" }.not_to raise_error
     expect { resource.failovermethod "bob" }.to raise_error(ArgumentError)
   end
 
   it "the http_caching property accepts 'packages', 'all', or 'none'" do
-    expect { resource.http_caching "packages" }.not_to raise_error(ArgumentError)
-    expect { resource.http_caching "all" }.not_to raise_error(ArgumentError)
-    expect { resource.http_caching "none" }.not_to raise_error(ArgumentError)
+    expect { resource.http_caching "packages" }.not_to raise_error
+    expect { resource.http_caching "all" }.not_to raise_error
+    expect { resource.http_caching "none" }.not_to raise_error
     expect { resource.http_caching "bob" }.to raise_error(ArgumentError)
   end
 
   it "the metadata_expire property accepts a time value or 'never'" do
-    expect { resource.metadata_expire "100" }.not_to raise_error(ArgumentError)
-    expect { resource.metadata_expire "100d" }.not_to raise_error(ArgumentError)
-    expect { resource.metadata_expire "100h" }.not_to raise_error(ArgumentError)
-    expect { resource.metadata_expire "100m" }.not_to raise_error(ArgumentError)
-    expect { resource.metadata_expire "never" }.not_to raise_error(ArgumentError)
+    expect { resource.metadata_expire "100" }.not_to raise_error
+    expect { resource.metadata_expire "100d" }.not_to raise_error
+    expect { resource.metadata_expire "100h" }.not_to raise_error
+    expect { resource.metadata_expire "100m" }.not_to raise_error
+    expect { resource.metadata_expire "never" }.not_to raise_error
     expect { resource.metadata_expire "100s" }.to raise_error(ArgumentError)
   end
 
   it "the mirror_expire property accepts a time value" do
-    expect { resource.mirror_expire "100" }.not_to raise_error(ArgumentError)
-    expect { resource.mirror_expire "100d" }.not_to raise_error(ArgumentError)
-    expect { resource.mirror_expire "100h" }.not_to raise_error(ArgumentError)
-    expect { resource.mirror_expire "100m" }.not_to raise_error(ArgumentError)
+    expect { resource.mirror_expire "100" }.not_to raise_error
+    expect { resource.mirror_expire "100d" }.not_to raise_error
+    expect { resource.mirror_expire "100h" }.not_to raise_error
+    expect { resource.mirror_expire "100m" }.not_to raise_error
     expect { resource.mirror_expire "never" }.to raise_error(ArgumentError)
   end
 
   it "the mirrorlist_expire property accepts a time value" do
-    expect { resource.mirrorlist_expire "100" }.not_to raise_error(ArgumentError)
-    expect { resource.mirrorlist_expire "100d" }.not_to raise_error(ArgumentError)
-    expect { resource.mirrorlist_expire "100h" }.not_to raise_error(ArgumentError)
-    expect { resource.mirrorlist_expire "100m" }.not_to raise_error(ArgumentError)
+    expect { resource.mirrorlist_expire "100" }.not_to raise_error
+    expect { resource.mirrorlist_expire "100d" }.not_to raise_error
+    expect { resource.mirrorlist_expire "100h" }.not_to raise_error
+    expect { resource.mirrorlist_expire "100m" }.not_to raise_error
     expect { resource.mirrorlist_expire "never" }.to raise_error(ArgumentError)
   end
 

data/spec/unit/resource_inspector_spec.rb

@@ -28,18 +28,23 @@ class DummyResource < Chef::Resource
   introduced "14.0"
   property :first, String, description: "My First Property", introduced: "14.0"
 
-  action :dummy do
+  action :dummy, description: "Dummy action" do
+    return true
+  end
+
+  action :dummy_no_desc do
     return true
   end
 end
 
-describe ResourceInspector do
+describe Chef::ResourceInspector do
   describe "inspecting a resource" do
-    subject { ResourceInspector.extract_resource(DummyResource, false) }
+    subject { Chef::ResourceInspector.extract_resource(DummyResource, false) }
 
     it "returns a hash with required data" do
       expect(subject[:description]).to eq "A dummy resource"
-      expect(subject[:actions]).to match_array %i{nothing dummy}
+      expect(subject[:actions]).to eq({ nothing: nil, dummy: "Dummy action",
+                                        dummy_no_desc: nil })
     end
 
     context "excluding built in properties" do
@@ -50,7 +55,7 @@ describe ResourceInspector do
     end
 
     context "including built in properties" do
-      subject { ResourceInspector.extract_resource(DummyResource, true) }
+      subject { Chef::ResourceInspector.extract_resource(DummyResource, true) }
       it "returns many properties" do
         expect(subject[:properties].count).to be > 1
         expect(subject[:properties].map { |n| n[:name] }).to include(:name, :first, :sensitive)

data/spec/unit/resource_reporter_spec.rb

@@ -19,7 +19,7 @@
 # limitations under the License.
 #
 
-require_relative "../spec_helper"
+require "spec_helper"
 require "chef/resource_reporter"
 require "socket"
 

data/spec/unit/resource_spec.rb

@@ -348,6 +348,11 @@ describe Chef::Resource do
     it "should recognize dynamically defined resources" do
       expect(resource.defined_at).to eq("dynamically defined")
     end
+
+    it "should return nil for the cookbook_version when the cookbook_name is @recipe_files" do
+      resource.cookbook_name = "@recipe_files"
+      expect(resource.cookbook_version).to be nil
+    end
   end
 
   describe "to_s" do
@@ -378,7 +383,7 @@ describe Chef::Resource do
       it "does not propagate validation errors" do
         resource_class = Class.new(Chef::Resource) { property :foo, String, required: true }
         resource = resource_class.new("required_property_tests")
-        expect { resource.to_text }.to_not raise_error Chef::Exceptions::ValidationFailed
+        expect { resource.to_text }.to_not raise_error
       end
     end
   end
@@ -492,6 +497,20 @@ describe Chef::Resource do
       expect(r.resource_name).to eq :blah
       expect(r.declared_type).to eq :d
     end
+
+    # This tests some somewhat confusing behavior that used to occur due to the resource_name call
+    # automatically wiring up the old canonical provides line.
+    it "setting resoure_name does not override provides in prior resource" do
+      c1 = Class.new(Chef::Resource) do
+        resource_name :self_resource_name_test_4
+        provides :self_resource_name_test_4
+      end
+      c2 = Class.new(Chef::Resource) do
+        resource_name :self_resource_name_test_4
+        provides(:self_resource_name_test_4) { false } # simulates any filter that does not match
+      end
+      expect(Chef::Resource.resource_for_node(:self_resource_name_test_4, node)).to eql(c1)
+    end
   end
 
   describe "to_json" do
@@ -912,14 +931,14 @@ describe Chef::Resource do
 
     it "adds mappings for all platforms", ruby: "< 2.7" do
       expect(Chef.resource_handler_map).to receive(:set).with(
-        :tape_deck, Chef::Resource::Klz, {}
+        :tape_deck, Chef::Resource::Klz
       )
       klz.provides :tape_deck
     end
 
     it "adds mappings for all platforms", ruby: ">= 2.7" do
       expect(Chef.resource_handler_map).to receive(:set).with(
-        :tape_deck, Chef::Resource::Klz
+        :tape_deck, Chef::Resource::Klz, {}
       )
       klz.provides :tape_deck
     end
@@ -1148,6 +1167,52 @@ describe Chef::Resource do
     end
   end
 
+  describe "#action_description" do
+    class TestResource < ::Chef::Resource
+      action :symbol_action, description: "a symbol test" do; end
+      action "string_action", description: "a string test" do; end
+      action :base_action0 do; end
+      action :base_action1, description: "unmodified base action 1 desc" do; end
+      action :base_action2, description: "unmodified base action 2 desc" do; end
+      action :base_action3, description: "unmodified base action 3 desc" do; end
+    end
+
+    it "returns nil when no description was provided for the action" do
+      expect(TestResource.action_description(:base_action0)).to eql(nil)
+    end
+
+    context "when action definition is a string" do
+      it "returns the description whether a symbol or string is used to look it up" do
+        expect(TestResource.action_description("string_action")).to eql("a string test")
+        expect(TestResource.action_description(:string_action)).to eql("a string test")
+      end
+    end
+
+    context "when action definition is a symbol" do
+      it "returns the description whether a symbol or string is used to look up" do
+        expect(TestResource.action_description("symbol_action")).to eql("a symbol test")
+        expect(TestResource.action_description(:symbol_action)).to eql("a symbol test")
+      end
+    end
+
+    context "when inheriting from an existing resource" do
+      class TestResourceChild < TestResource
+        action :base_action2, description: "modified base action 2 desc" do; end
+        action :base_action3 do; end
+      end
+
+      it "returns original description when a described action is not overridden in child resource" do
+        expect(TestResourceChild.action_description(:base_action1)).to eq "unmodified base action 1 desc"
+      end
+      it "returns original description when the child resource overrides an inherited action but NOT its description" do
+        expect(TestResourceChild.action_description(:base_action3)).to eq "unmodified base action 3 desc"
+      end
+      it "returns new description when the child resource overrides an inherited action and its description" do
+        expect(TestResourceChild.action_description(:base_action2)).to eq "modified base action 2 desc"
+      end
+    end
+  end
+
   describe ".default_action" do
     let(:default_action) {}
     let(:resource_class) do
@@ -1222,4 +1287,73 @@ describe Chef::Resource do
       expect(resource.tagged?("foo")).to be(false)
     end
   end
+
+  describe "#with_umask" do
+    let(:resource) { Chef::Resource.new("testy testerson") }
+    let!(:original_umask) { ::File.umask }
+
+    after do
+      ::File.umask(original_umask)
+    end
+
+    it "does not affect the umask by default" do
+      block_value = nil
+
+      resource.with_umask do
+        block_value = ::File.umask
+      end
+
+      expect(block_value).to eq(original_umask)
+    end
+
+    if windows?
+      it "is a no-op on Windows" do
+        resource.umask = "0123"
+
+        block_value = nil
+
+        resource.with_umask do
+          block_value = ::File.umask
+        end
+
+        # Format the returned value so a potential error message is easier to understand.
+        actual_value = block_value.to_s(8).rjust(4, "0")
+
+        expect(actual_value).to eq("0000")
+      end
+    else
+      it "changes the umask in the block to the set value" do
+        resource.umask = "0123"
+
+        block_value = nil
+
+        resource.with_umask do
+          block_value = ::File.umask
+        end
+
+        # Format the returned value so a potential error message is easier to understand.
+        actual_value = block_value.to_s(8).rjust(4, "0")
+
+        expect(actual_value).to eq("0123")
+      end
+    end
+
+    it "resets the umask afterwards" do
+      resource.umask = "0123"
+
+      resource.with_umask do
+        "noop"
+      end
+
+      expect(::File.umask).to eq(original_umask)
+    end
+
+    it "resets the umask if the block raises an error" do
+      resource.umask = "0123"
+
+      expect { resource.with_umask { 1 / 0 } }.to raise_error(ZeroDivisionError)
+
+      expect(::File.umask).to eq(original_umask)
+    end
+  end
 end