chef 16.1.16-universal-mingw32 → 16.3.45-universal-mingw32

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

@@ -20,16 +20,117 @@ require "spec_helper"
 describe Chef::Resource::MacosUserDefaults do
 
   let(:resource) { Chef::Resource::MacosUserDefaults.new("foo") }
+  let(:provider) { resource.provider_for_action(:write) }
 
   it "has a resource name of :macos_userdefaults" do
-    expect(resource.resource_name).to eql(:macos_userdefaults)
+    expect(resource.resource_name).to eq(:macos_userdefaults)
+  end
+
+  it "the domain property defaults to NSGlobalDomain" do
+    expect(resource.domain).to eq("NSGlobalDomain")
+  end
+
+  it "the value property coerces keys in hashes to strings so we can compare them with plist data" do
+    resource.value "User": "/Library/Managed Installs/way_fake.log"
+    expect(resource.value).to eq({ "User" => "/Library/Managed Installs/way_fake.log" })
+  end
+
+  it "the host property defaults to nil" do
+    expect(resource.host).to be_nil
+  end
+
+  it "the sudo property defaults to false" do
+    expect(resource.sudo).to be false
   end
 
   it "sets the default action as :write" do
-    expect(resource.action).to eql([:write])
+    expect(resource.action).to eq([:write])
   end
 
   it "supports :write action" do
     expect { resource.action :write }.not_to raise_error
   end
+
+  describe "#defaults_export_cmd" do
+    it "exports NSGlobalDomain if no domain is set" do
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "export", "NSGlobalDomain", "-"])
+    end
+
+    it "exports a provided domain" do
+      resource.domain "com.tim"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "export", "com.tim", "-"])
+    end
+
+    it "sets -currentHost if host is 'current'" do
+      resource.host "current"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "-currentHost", "export", "NSGlobalDomain", "-"])
+    end
+
+    it "sets -host 'tim-laptop if host is 'tim-laptop'" do
+      resource.host "tim-laptop"
+      expect(provider.defaults_export_cmd(resource)).to eq(["/usr/bin/defaults", "-host", "tim-laptop", "export", "NSGlobalDomain", "-"])
+    end
+  end
+
+  describe "#defaults_modify_cmd" do
+    # avoid needing to set these required values over and over. We'll overwrite them where necessary
+    before do
+      resource.key = "foo"
+      resource.value = "bar"
+    end
+
+    it "writes to NSGlobalDomain if domain isn't specified" do
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "uses the domain property if set" do
+      resource.domain = "MyCustomDomain"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "MyCustomDomain", "foo", "-string", "bar"])
+    end
+
+    it "sets host specific values using host property" do
+      resource.host = "tims_laptop"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "-host", "tims_laptop", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "if host is set to :current it passes CurrentHost" do
+      resource.host = :current
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "-currentHost", "write", "NSGlobalDomain", "foo", "-string", "bar"])
+    end
+
+    it "raises ArgumentError if bool is specified, but the value can't be made into a bool" do
+      resource.type "bool"
+      expect { provider.defaults_modify_cmd }.to raise_error(ArgumentError)
+    end
+
+    it "autodetects array type and passes individual values" do
+      resource.value = %w{one two three}
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-array", "one", "two", "three"])
+    end
+
+    it "autodetects string type and passes a single value" do
+      resource.value = "one"
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-string", "one"])
+    end
+
+    it "autodetects integer type and passes a single value" do
+      resource.value = 1
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-int", 1])
+    end
+
+    it "autodetects boolean type from TrueClass value and passes a 'TRUE' string" do
+      resource.value = true
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-bool", "TRUE"])
+    end
+
+    it "autodetects boolean type from FalseClass value and passes a 'FALSE' string" do
+      resource.value = false
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-bool", "FALSE"])
+    end
+
+    it "autodetects dict type from Hash value and flattens keys & values" do
+      resource.value = { "foo" => "bar" }
+      expect(provider.defaults_modify_cmd).to eq(["/usr/bin/defaults", "write", "NSGlobalDomain", "foo", "-dict", "foo", "bar"])
+    end
+  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_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
 

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