chef 16.0.287 → 16.2.73

data/spec/unit/resource/cron_spec.rb

@@ -132,10 +132,10 @@ describe Chef::Resource::Cron do
 
   describe "weekday" do
     it "rejects any weekday over 7" do
-      expect { resource.weekday "8" }.to raise_error(RangeError)
+      expect { resource.weekday "8" }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
     it "rejects any symbols which don't represent day of week" do
-      expect { resource.weekday :foo }.to raise_error(RangeError)
+      expect { resource.weekday :foo }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
   end
 

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

@@ -112,7 +112,8 @@ describe Chef::Resource::File::Verification do
       end
 
       it "returns true if the command succeeds" do
-        v = Chef::Resource::File::Verification.new(parent_resource, "true", {})
+        test_command = platform_specific_verify_command("path")
+        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
         expect(v.verify(temp_path)).to eq(true)
       end
 

data/spec/unit/resource/helpers/cron_validations_spec.rb

@@ -34,8 +34,12 @@ describe Chef::ResourceHelpers::CronValidations do
       expect(Chef::ResourceHelpers::CronValidations.validate_dow(8)).to be false
     end
 
+    it "it accepts the string day with full name" do
+      expect(Chef::ResourceHelpers::CronValidations.validate_dow("monday")).to be true
+    end
+
     it "returns false for an invalid string" do
-      expect(Chef::ResourceHelpers::CronValidations.validate_dow("monday")).to be false
+      expect(Chef::ResourceHelpers::CronValidations.validate_dow("funday")).to be false
     end
   end
 

data/spec/unit/resource/homebrew_update_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Chef::Resource::HomebrewUpdate do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::HomebrewUpdate.new("update", run_context) }
+
+  let(:stamp_dir) { Dir.mktmpdir("brew_update_periodic") }
+  let(:stamp_file) { Dir.mktmpdir("apt_update_periodic") }
+  let(:brew_update_cmd) { %w{homebrew update} }
+
+  it "sets the default action as :periodic" do
+    expect(resource.action).to eql([:periodic])
+  end
+
+  it "supports :periodic, :update actions" do
+    expect { resource.action :periodic }.not_to raise_error
+    expect { resource.action :update }.not_to raise_error
+  end
+
+  it "default frequency is set to be 1 da1y" do
+    expect(resource.frequency).to eql(86_400)
+  end
+
+  it "frequency accepts integers" do
+    resource.frequency(400)
+    expect(resource.frequency).to eql(400)
+  end
+end

data/spec/unit/resource/powershell_script_spec.rb

@@ -136,23 +136,18 @@ describe Chef::Resource::PowershellScript do
     it_behaves_like "a Windows script resource"
   end
 
-  context "Attribute: flags" do
+  describe "#flags" do
     let(:resource) { @resource }
-    let(:default) { "FLAGS" }
-    before(:each) do
-      allow(@resource).to receive(:default_flags).and_return(default)
-    end
-    context "When User input given" do
-      it "Appands user input after the default flags" do
-        flags = "USER FLAGS"
-        resource.flags flags
-        expect(resource.flags).to eql(default + " " + flags)
-      end
+
+    it "appends user's flags to the defaults" do
+      flags = %q{-Lunch "tacos"}
+      resource.flags = flags
+
+      expect(resource.flags).to eq("#{resource.default_flags} #{flags}")
     end
-    context "When User input is not given" do
-      it "Uses default flags" do
-        expect(resource.flags).to eql(default)
-      end
+
+    it "uses the defaults when user doesn't provide flags" do
+      expect(resource.flags).to eq(resource.default_flags)
     end
   end
 end

data/spec/unit/resource/timezone_spec.rb

@@ -34,6 +34,6 @@ describe Chef::Resource::Timezone do
 
   it "supports the :set action only" do
     expect { resource.action :set }.not_to raise_error
-    expect { resource.action :unset }.to raise_error
+    expect { resource.action :unset }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 end

data/spec/unit/resource/windows_audit_policy_spec.rb

@@ -0,0 +1,64 @@
+#
+# 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::WindowsAuditPolicy do
+  let(:resource) { Chef::Resource::WindowsAuditPolicy.new("fakey_fakerton") }
+
+  it "sets resource name as :windows_audit_policy" do
+    expect(resource.resource_name).to eql(:windows_audit_policy)
+  end
+
+  it "expects crash_on_audit_fail to have a true or false value if entered" do
+    expect { resource.crash_on_audit_fail "not_a_true_or_false" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects full_privilege_auditing to have a true or false value if entered" do
+    expect { resource.full_privilege_auditing "not_a_true_or_false" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects audit_base_objects to have a true or false value if entered" do
+    expect { resource.audit_base_objects "not_a_true_or_false" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects audit_base_directories to have a true or false value if entered" do
+    expect { resource.audit_base_directories "not_a_true_or_false" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects success property to have a true or false value if entered" do
+    expect { resource.success "not_a_true_or_false" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "expects failure property to have a true or false value if entered" do
+    expect { resource.failure "not_a_true_or_false" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  Chef::Resource::WindowsAuditPolicy::WIN_AUDIT_SUBCATEGORIES.each do |val|
+    it "the subcategory property accepts :#{val}" do
+      expect { resource.subcategory val }.not_to raise_error
+    end
+  end
+
+  it "the resource raises an ArgumentError if invalid subcategory property is set" do
+    expect { resource.subcategory "Logount" }.to raise_error(ArgumentError)
+  end
+
+  it "sets the default action as :set" do
+    expect(resource.action).to eql([:set])
+  end
+end

data/spec/unit/resource/windows_dns_record_spec.rb

@@ -29,15 +29,15 @@ describe Chef::Resource::WindowsDnsRecord do
   end
 
   it "the record_type property accepts 'CNAME'" do
-    expect { resource.record_type "CNAME" }.not_to raise_error(ArgumentError)
+    expect { resource.record_type "CNAME" }.not_to raise_error
   end
 
   it "the record_type property accepts 'ARecord'" do
-    expect { resource.record_type "ARecord" }.not_to raise_error(ArgumentError)
+    expect { resource.record_type "ARecord" }.not_to raise_error
   end
 
   it "the record_type property accepts 'PTR'" do
-    expect { resource.record_type "PTR" }.not_to raise_error(ArgumentError)
+    expect { resource.record_type "PTR" }.not_to raise_error
   end
 
   it "the resource raises an ArgumentError if invalid record_type is set" do

data/spec/unit/resource/windows_dns_zone_spec.rb

@@ -29,11 +29,11 @@ describe Chef::Resource::WindowsDnsZone do
   end
 
   it "the server_type property accepts 'Standalone'" do
-    expect { resource.server_type "Standalone" }.not_to raise_error(ArgumentError)
+    expect { resource.server_type "Standalone" }.not_to raise_error
   end
 
   it "the server_type property accepts 'Domain'" do
-    expect { resource.server_type "Domain" }.not_to raise_error(ArgumentError)
+    expect { resource.server_type "Domain" }.not_to raise_error
   end
 
   it "the resource raises an ArgumentError if invalid server_type is set" do

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
 

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_spec.rb

@@ -378,7 +378,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 +492,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
@@ -1222,4 +1236,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

data/spec/unit/role_spec.rb

@@ -310,50 +310,52 @@ describe Chef::Role do
   describe "when loading from disk and role_path is an array" do
 
     before(:each) do
-      Chef::Config[:role_path] = ["/path1", "/path/path2"]
+      Chef::Config[:role_path] = ["/path1", "/path1/path2"]
     end
 
+    let(:root) { windows? ? "C:/path1" : "/path1" }
+
     it "should return a Chef::Role object from JSON" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return(["/path1/lolcat.json"])
-      expect(File).to receive(:exists?).with("/path1/lolcat.json").exactly(1).times.and_return(true)
-      expect(IO).to receive(:read).with("/path1/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return(["#{root}/lolcat.json"])
+      expect(File).to receive(:exists?).with("#{root}/lolcat.json").exactly(1).times.and_return(true)
+      expect(IO).to receive(:read).with("#{root}/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from JSON when role is in the second path" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return(["/path/path2/lolcat.json"])
-      expect(File).to receive(:exists?).with("/path/path2/lolcat.json").exactly(1).times.and_return(true)
-      expect(IO).to receive(:read).with("/path/path2/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return(["#{root}/path2/lolcat.json"])
+      expect(File).to receive(:exists?).with("#{root}/path2/lolcat.json").exactly(1).times.and_return(true)
+      expect(IO).to receive(:read).with("#{root}/path2/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from a Ruby DSL" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return(["/path1/lolcat.rb"])
-      expect(File).to receive(:exists?).with("/path1/lolcat.rb").exactly(1).times.and_return(true)
-      expect(File).to receive(:readable?).with("/path1/lolcat.rb").and_return(true)
-      expect(File).to receive(:file?).with("/path1/lolcat.rb").and_return(true)
-      expect(IO).to receive(:read).with("/path1/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return(["#{root}/lolcat.rb"])
+      expect(File).to receive(:exists?).with("#{root}/lolcat.rb").exactly(1).times.and_return(true)
+      expect(File).to receive(:readable?).with("#{root}/lolcat.rb").and_return(true)
+      expect(File).to receive(:file?).with("#{root}/lolcat.rb").and_return(true)
+      expect(IO).to receive(:read).with("#{root}/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should return a Chef::Role object from a Ruby DSL when role is in the second path" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return(["/path/path2/lolcat.rb"])
-      expect(File).to receive(:exists?).with("/path/path2/lolcat.rb").exactly(1).times.and_return(true)
-      expect(File).to receive(:readable?).with("/path/path2/lolcat.rb").and_return(true)
-      expect(File).to receive(:file?).with("/path/path2/lolcat.rb").and_return(true)
-      expect(IO).to receive(:read).with("/path/path2/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return(["#{root}/path2/lolcat.rb"])
+      expect(File).to receive(:exists?).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(true)
+      expect(File).to receive(:readable?).with("#{root}/path2/lolcat.rb").and_return(true)
+      expect(File).to receive(:file?).with("#{root}/path2/lolcat.rb").and_return(true)
+      expect(IO).to receive(:read).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
     end
 
     it "should raise an exception if the file does not exist" do
-      expect(Dir).to receive(:glob).with(File.join("/path1", "**", "**")).exactly(1).times.and_return([])
-      expect(Dir).to receive(:glob).with(File.join("/path/path2", "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
+      expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return([])
       expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::RoleNotFound)
     end