chef 16.0.275-universal-mingw32 → 16.2.50-universal-mingw32

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/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_package_spec.rb

@@ -93,6 +93,16 @@ describe Chef::Resource::WindowsPackage, "initialize" do
     expect(resource.returns).to eq([0, 3010])
   end
 
+  it "does not accept a string for the package_name property" do
+    expect { resource.package_name(%w{this should break}) }.to raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  # even though we don't do anything with arrays of versions we need them for current_value
+  it "accepts both Strings and Arrays for the version property" do
+    expect { resource.version "1.2.3" }.not_to raise_error
+    expect { resource.version ["1.2.3", "1.2.3.4"] }.not_to raise_error
+  end
+
   it "defaults source to the resource name" do
     # it's a little late to stub out File.absolute_path
     expect(resource.source).to include("solitaire.msi")

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,56 @@ 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
+
+    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
+
+    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/run_context_spec.rb

@@ -138,7 +138,7 @@ describe Chef::RunContext do
       expect(node).to receive(:loaded_recipe).with(:ancient, "aliens")
       expect do
         run_context.include_recipe("ancient::aliens")
-      # In CHEF-5120, this becomes a Chef::Exceptions::MissingCookbookDependency error:
+        # In CHEF-5120, this becomes a Chef::Exceptions::MissingCookbookDependency error:
       end.to raise_error(Chef::Exceptions::CookbookNotFound)
     end
 

data/spec/unit/util/dsc/configuration_generator_spec.rb

@@ -161,7 +161,7 @@ describe Chef::Util::DSC::ConfigurationGenerator do
       dsc = conf_man.send(:configuration_code, "archive{}", "hello", {})
       found_configuration = false
       dsc.split(";").each do |command|
-        if command.downcase =~ /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/
+        if /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/.match?(command.downcase)
           found_configuration = true
         end
       end

data/spec/unit/util/threaded_job_queue_spec.rb

@@ -21,6 +21,15 @@ end
 describe Chef::Util::ThreadedJobQueue do
   let(:queue) { Chef::Util::ThreadedJobQueue.new }
 
+  around(:example) do |example|
+    old_value = Thread.report_on_exception
+    Thread.report_on_exception = false
+
+    example.run
+
+    Thread.report_on_exception = old_value
+  end
+
   it "should pass mutex to jobs with an arity of 1" do
     job = double
     expect(job).to receive(:arity).at_least(:once).and_return(1)

data/spec/unit/win32/registry_spec.rb

@@ -30,7 +30,7 @@ describe Chef::Win32::Registry do
   let(:sub_key) { "OpscodePrimes" }
   let(:missing_key_path) { 'HKCU\Software' }
   let(:registry) { Chef::Win32::Registry.new }
-  let(:hive_mock) { double("::Win32::Registry::KHKEY_CURRENT_USER") }
+  let(:hive_mock) { double("::Win32::Registry::HKEY_CURRENT_USER") }
   let(:reg_mock) { double("reg") }
 
   before(:all) do