chef 16.1.16 → 16.18.30

data/spec/unit/resource/powershell_script_spec.rb

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Resource::PowershellScript do
 
-  before(:each) do
+  let(:resource) do
     node = Chef::Node.new
 
     node.default["kernel"] = {}
@@ -29,130 +29,37 @@ describe Chef::Resource::PowershellScript do
 
     run_context = Chef::RunContext.new(node, nil, nil)
 
-    @resource = Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
+    Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
   end
 
   it "creates a new Chef::Resource::PowershellScript" do
-    expect(@resource).to be_a_kind_of(Chef::Resource::PowershellScript)
+    expect(resource).to be_a_kind_of(Chef::Resource::PowershellScript)
   end
 
   it "sets convert_boolean_return to false by default" do
-    expect(@resource.convert_boolean_return).to eq(false)
+    expect(resource.convert_boolean_return).to eq(false)
   end
 
   it "returns the value for convert_boolean_return that was set" do
-    @resource.convert_boolean_return true
-    expect(@resource.convert_boolean_return).to eq(true)
-    @resource.convert_boolean_return false
-    expect(@resource.convert_boolean_return).to eq(false)
+    resource.convert_boolean_return true
+    expect(resource.convert_boolean_return).to eq(true)
+    resource.convert_boolean_return false
+    expect(resource.convert_boolean_return).to eq(false)
   end
 
-  context "when using guards" do
-    let(:resource) { @resource }
-    before(:each) do
-      allow(resource).to receive(:run_action)
-      allow(resource).to receive(:updated).and_return(true)
-    end
+  it "inherits exactly the :cwd, :domain, :environment, :group, :password, :path, :user, :umask, :architecture, :elevated, :interpreter properties from a parent resource class" do
+    inherited_difference = Chef::Resource::PowershellScript.guard_inherited_attributes -
+      %i{cwd domain environment group password path user umask architecture elevated interpreter}
 
-    it "inherits exactly the :cwd, :environment, :group, :path, :user, :umask, :architecture, :elevated properties from a parent resource class" do
-      inherited_difference = Chef::Resource::PowershellScript.guard_inherited_attributes -
-        %i{cwd environment group path user umask architecture elevated}
-
-      expect(inherited_difference).to eq([])
-    end
-
-    it "allows guard interpreter to be set to Chef::Resource::Script" do
-      resource.guard_interpreter(:script)
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
-      resource.only_if("echo hi")
-    end
-
-    it "allows guard interpreter to be set to Chef::Resource::Bash derived from Chef::Resource::Script" do
-      resource.guard_interpreter(:bash)
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
-      resource.only_if("echo hi")
-    end
-
-    it "allows guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
-      resource.guard_interpreter(:powershell_script)
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(false)
-      resource.only_if("echo hi")
-    end
-
-    it "enables convert_boolean_return by default for guards in the context of powershell_script when no guard params are specified" do
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:evaluate_action).and_return(true)
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { convert_boolean_return: true, code: "$true" }
-      ).and_return(Proc.new {})
-      resource.only_if("$true")
-    end
-
-    it "enables convert_boolean_return by default for guards in non-Chef::Resource::Script derived resources when no guard params are specified" do
-      node = Chef::Node.new
-      run_context = Chef::RunContext.new(node, nil, nil)
-      file_resource = Chef::Resource::File.new("idontexist", run_context)
-      file_resource.guard_interpreter :powershell_script
-
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { convert_boolean_return: true, code: "$true" }
-      ).and_return(Proc.new {})
-      resource.only_if("$true")
-    end
-
-    it "enables convert_boolean_return by default for guards in the context of powershell_script when guard params are specified" do
-      guard_parameters = { cwd: "/etc/chef", architecture: :x86_64 }
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { convert_boolean_return: true, code: "$true" }.merge(guard_parameters)
-      ).and_return(Proc.new {})
-      resource.only_if("$true", guard_parameters)
-    end
-
-    it "passes convert_boolean_return as true if it was specified as true in a guard parameter" do
-      guard_parameters = { cwd: "/etc/chef", convert_boolean_return: true, architecture: :x86_64 }
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        { convert_boolean_return: true, code: "$true" }.merge(guard_parameters)
-      ).and_return(Proc.new {})
-      resource.only_if("$true", guard_parameters)
-    end
-
-    it "passes convert_boolean_return as false if it was specified as true in a guard parameter" do
-      other_guard_parameters = { cwd: "/etc/chef", architecture: :x86_64 }
-      parameters_with_boolean_disabled = other_guard_parameters.merge({ convert_boolean_return: false, code: "$true" })
-      allow_any_instance_of(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:block_from_attributes).with(
-        parameters_with_boolean_disabled
-      ).and_return(Proc.new {})
-      resource.only_if("$true", parameters_with_boolean_disabled)
-    end
+    expect(inherited_difference).to eq([])
   end
 
   context "as a script running in Windows-based scripting language" do
-    let(:resource_instance) { @resource }
-    let(:resource_instance_name ) { @resource.command }
+    let(:windows_script_resource) { resource }
+    let(:resource_instance_name ) { resource.command }
     let(:resource_name) { :powershell_script }
     let(:interpreter_file_name) { "powershell.exe" }
-    before do
-      allow(@resource).to receive(:default_flags).and_return(nil)
-    end
-    it_behaves_like "a Windows script resource"
-  end
 
-  context "Attribute: 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
-    end
-    context "When User input is not given" do
-      it "Uses default flags" do
-        expect(resource.flags).to eql(default)
-      end
-    end
+    it_behaves_like "a Windows script resource"
   end
 end

data/spec/unit/resource/rhsm_register_spec.rb

@@ -41,23 +41,34 @@ describe Chef::Resource::RhsmRegister do
   end
 
   describe "#katello_cert_rpm_installed?" do
-    let(:cmd) { double("cmd") }
-
-    before do
-      allow(Mixlib::ShellOut).to receive(:new).and_return(cmd)
-      allow(cmd).to receive(:run_command)
-    end
-
     context "when the output contains katello-ca-consumer" do
+      let(:with_katello) { double("shell_out", stdout: <<~RPM) }
+        libevent-2.0.21-4.el7.x86_64
+        gettext-libs-0.19.8.1-3.el7.x86_64
+        yum-metadata-parser-1.1.4-10.el7.x86_64
+        pyliblzma-0.5.3-11.el7.x86_64
+        python-IPy-0.75-6.el7.noarch
+        grubby-8.28-26.el7.x86_64
+        fipscheck-lib-1.4.1-6.el7.x86_64
+        centos-logos-70.0.6-3.el7.centos.noarch
+        nss-tools-3.44.0-7.el7_7.x86_64
+        katello-ca-consumer-somehostname-1.0-1.el7.x86_64
+        rpm-4.11.3-43.el7.x86_64
+        gpgme-1.3.2-5.el7.x86_64
+        libnfsidmap-0.25-19.el7.x86_64
+      RPM
+
       it "returns true" do
-        allow(cmd).to receive(:stdout).and_return("katello-ca-consumer-somehostname-1.0-1")
+        allow(provider).to receive(:shell_out).and_return(with_katello)
         expect(provider.katello_cert_rpm_installed?).to eq(true)
       end
     end
 
     context "when the output does not contain katello-ca-consumer" do
+      let(:without_katello) { double("shell_out", stdout: "") }
+
       it "returns false" do
-        allow(cmd).to receive(:stdout).and_return("katello-agent-but-not-the-ca")
+        allow(provider).to receive(:shell_out).and_return(without_katello)
         expect(provider.katello_cert_rpm_installed?).to eq(false)
       end
     end
@@ -89,6 +100,22 @@ describe Chef::Resource::RhsmRegister do
         end
       end
 
+      context "when a system_name is provided" do
+        it "returns a command containing the system name" do
+          allow(resource).to receive(:organization).and_return("myorg")
+          allow(resource).to receive(:system_name).and_return("myname")
+          expect(provider.register_command).to match("--name=myname")
+        end
+      end
+
+      context "when a system_name is not provided" do
+        it "returns a command containing the system name" do
+          allow(resource).to receive(:organization).and_return("myorg")
+          allow(resource).to receive(:system_name).and_return(nil)
+          expect(provider.register_command).not_to match("--name")
+        end
+      end
+
       context "when auto_attach is true" do
         it "does not return a command with --auto-attach since it is not supported with activation keys" do
           allow(resource).to receive(:organization).and_return("myorg")
@@ -124,6 +151,20 @@ describe Chef::Resource::RhsmRegister do
         end
       end
 
+      context "when a system_name is provided" do
+        it "returns a command containing the system name" do
+          allow(resource).to receive(:system_name).and_return("myname")
+          expect(provider.register_command).to match("--name=myname")
+        end
+      end
+
+      context "when a system_name is not provided" do
+        it "returns a command containing the system name" do
+          allow(resource).to receive(:system_name).and_return(nil)
+          expect(provider.register_command).not_to match("--name")
+        end
+      end
+
       context "when auto_attach is nil" do
         it "returns a command that does not contain --auto-attach" do
           allow(resource).to receive(:auto_attach).and_return(nil)
@@ -204,23 +245,20 @@ describe Chef::Resource::RhsmRegister do
   end
 
   describe "#registered_with_rhsm?" do
-    let(:cmd) { double("cmd") }
-
-    before do
-      allow(Mixlib::ShellOut).to receive(:new).and_return(cmd)
-      allow(cmd).to receive(:run_command)
-    end
-
     context "when the status is Unknown" do
+      let(:unknown_status) { double("shell_out", stdout: "Overall Status: Unknown") }
+
       it "returns false" do
-        allow(cmd).to receive(:stdout).and_return("Overall Status: Unknown")
+        allow(provider).to receive(:shell_out).and_return(unknown_status)
         expect(provider.registered_with_rhsm?).to eq(false)
       end
     end
 
     context "when the status is anything else" do
+      let(:known_status) { double("shell_out", stdout: "Overall Status: Insufficient") }
+
       it "returns true" do
-        allow(cmd).to receive(:stdout).and_return("Overall Status: Insufficient")
+        allow(provider).to receive(:shell_out).and_return(known_status)
         expect(provider.registered_with_rhsm?).to eq(true)
       end
     end

data/spec/unit/resource/rhsm_subscription_spec.rb

@@ -18,15 +18,24 @@
 require "spec_helper"
 
 describe Chef::Resource::RhsmSubscription do
-  let(:resource) { Chef::Resource::RhsmSubscription.new("fakey_fakerton") }
-  let(:provider) { resource.provider_for_action(:attach) }
+  let(:event_dispatch) { Chef::EventDispatch::Dispatcher.new }
+  let(:node) { Chef::Node.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, event_dispatch) }
+
+  let(:pool_id) { "8a8dd78c766232550226b46e59404aba" }
+  let(:resource) { Chef::Resource::RhsmSubscription.new(pool_id, run_context) }
+  let(:provider) { resource.provider_for_action(Array(resource.action).first) }
+
+  before do
+    allow(resource).to receive(:provider_for_action).with(:attach).and_return(provider)
+  end
 
   it "has a resource name of :rhsm_subscription" do
     expect(resource.resource_name).to eql(:rhsm_subscription)
   end
 
   it "the pool_id property is the name_property" do
-    expect(resource.pool_id).to eql("fakey_fakerton")
+    expect(resource.pool_id).to eql(pool_id)
   end
 
   it "sets the default action as :attach" do
@@ -38,6 +47,44 @@ describe Chef::Resource::RhsmSubscription do
     expect { resource.action :remove }.not_to raise_error
   end
 
+  describe "#action_attach" do
+    let(:yum_package_double) { instance_double("Chef::Resource::YumPackage") }
+    let(:so_double) { instance_double("Mixlib::ShellOut", stdout: "Successfully attached a subscription for: My Subscription", exitstatus: 0, error?: false) }
+
+    before do
+      allow(provider).to receive(:shell_out!).with("subscription-manager attach --pool=#{resource.pool_id}").and_return(so_double)
+      allow(provider).to receive(:build_resource).with(:package, "rhsm_subscription-#{pool_id}-flush_cache").and_return(yum_package_double)
+      allow(yum_package_double).to receive(:run_action).with(:flush_cache)
+    end
+
+    context "when already attached to pool" do
+      before do
+        allow(provider).to receive(:subscription_attached?).with(resource.pool_id).and_return(true)
+      end
+
+      it "does not attach to pool" do
+        expect(provider).not_to receive(:shell_out!)
+        resource.run_action(:attach)
+      end
+    end
+
+    context "when not attached to pool" do
+      before do
+        allow(provider).to receive(:subscription_attached?).with(resource.pool_id).and_return(false)
+      end
+
+      it "attaches to pool" do
+        expect(provider).to receive(:shell_out!).with("subscription-manager attach --pool=#{resource.pool_id}")
+        resource.run_action(:attach)
+      end
+
+      it "flushes package provider cache" do
+        expect(yum_package_double).to receive(:run_action).with(:flush_cache)
+        resource.run_action(:attach)
+      end
+    end
+  end
+
   describe "#subscription_attached?" do
     let(:cmd)    { double("cmd") }
     let(:output) { "Pool ID:    pool123" }

data/spec/unit/resource/script_spec.rb

@@ -21,9 +21,14 @@ require "spec_helper"
 
 describe Chef::Resource::Script do
   let(:resource_instance_name) { "fakey_fakerton" }
-  let(:script_resource) { Chef::Resource::Script.new(resource_instance_name) }
   let(:resource_name) { :script }
 
+  let(:script_resource) do
+    run_context = Chef::RunContext.new(Chef::Node.new, nil, nil)
+
+    Chef::Resource::Script.new(resource_instance_name, run_context)
+  end
+
   it "sets the default action as :run" do
     expect(script_resource.action).to eql([:run])
   end

data/spec/unit/resource/service_spec.rb

@@ -62,7 +62,7 @@ describe Chef::Resource::Service do
 
   it "does not accept a regexp for the service pattern" do
     expect do
-      resource.pattern /.*/
+      resource.pattern(/.*/)
     end.to raise_error(ArgumentError)
   end
 
@@ -89,7 +89,7 @@ describe Chef::Resource::Service do
 
   it "does not accept a regexp for the init_command property" do
     expect do
-      resource.init_command /.*/
+      resource.init_command(/.*/)
     end.to raise_error(ArgumentError)
   end
 

data/spec/unit/resource/solaris_package_spec.rb

@@ -21,16 +21,14 @@ require "support/shared/unit/resource/static_provider_resolution"
 
 describe Chef::Resource::SolarisPackage, "initialize" do
 
-  %w{solaris2 nexentacore}.each do |platform_family|
-    static_provider_resolution(
-      resource: Chef::Resource::SolarisPackage,
-      provider: Chef::Provider::Package::Solaris,
-      name: :solaris_package,
-      action: :install,
-      os: "solaris2",
-      platform_family: platform_family
-    )
-  end
+  static_provider_resolution(
+    resource: Chef::Resource::SolarisPackage,
+    provider: Chef::Provider::Package::Solaris,
+    name: :solaris_package,
+    action: :install,
+    os: "solaris2",
+    platform_family: "solaris2"
+  )
 
   let(:resource) { Chef::Resource::SolarisPackage.new("foo") }
 

data/spec/unit/resource/systemd_unit_spec.rb

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Resource::SystemdUnit do
   let(:resource) { Chef::Resource::SystemdUnit.new("sysstat-collect.timer") }
-  let(:unit_content_string) { "[Unit]\nDescription = Run system activity accounting tool every 10 minutes\nDocumentation = foo\nDocumentation = bar\n\n[Timer]\nOnCalendar = *:00/10\n\n[Install]\nWantedBy = sysstat.service\n" }
+  let(:unit_content_string) { "[Unit]\nDescription=Run system activity accounting tool every 10 minutes\nDocumentation=foo\nDocumentation=bar\n\n[Timer]\nOnCalendar=*:00/10\n\n[Install]\nWantedBy=sysstat.service\n" }
   let(:unit_content_hash) do
     {
       "Unit" => {

data/spec/unit/resource/timezone_spec.rb

@@ -20,6 +20,31 @@ require "spec_helper"
 describe Chef::Resource::Timezone do
   let(:resource) { Chef::Resource::Timezone.new("fakey_fakerton") }
 
+  let(:shellout_tzutil) do
+    double("shell_out", stdout: "UTC\n", exitstatus: 0, error?: false)
+  end
+
+  # note: This weird indention is correct
+  let(:shellout_timedatectl) do
+    double("shell_out", exitstatus: 0, error?: false, stdout: <<-OUTPUT)
+    Local time: Tue 2020-08-18 20:55:05 UTC
+    Universal time: Tue 2020-08-18 20:55:05 UTC
+          RTC time: Tue 2020-08-18 20:55:05
+         Time zone: Etc/UTC (UTC, +0000)
+System clock synchronized: yes
+systemd-timesyncd.service active: yes
+   RTC in local TZ: no
+    OUTPUT
+  end
+
+  let(:shellout_systemsetup_fail) do
+    double("shell_out!", stdout: "You need administrator access to run this tool... exiting!", exitstatus: 0, error?: false) # yes it's a non-error exit
+  end
+
+  let(:shellout_systemsetup) do
+    double("shell_out!", stdout: "Time Zone: UTC", exitstatus: 0, error?: false)
+  end
+
   it "sets resource name as :timezone" do
     expect(resource.resource_name).to eql(:timezone)
   end
@@ -34,6 +59,44 @@ 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
+
+  describe "#current_macos_tz" do
+    context "with admin privs" do
+      it "returns the TZ" do
+        expect(resource).to receive(:shell_out!).and_return(shellout_systemsetup)
+        expect(resource.current_macos_tz).to eql("UTC")
+      end
+    end
+
+    context "without admin privs" do
+      it "returns the TZ" do
+        expect(resource).to receive(:shell_out!).and_return(shellout_systemsetup_fail)
+        expect { resource.current_macos_tz }.to raise_error(RuntimeError, "The timezone resource requires administrative privileges to run on macOS hosts!")
+      end
+    end
+  end
+
+  describe "#current_systemd_tz" do
+    it "returns the TZ" do
+      expect(resource).to receive(:shell_out).and_return(shellout_timedatectl)
+      expect(resource.current_systemd_tz).to eql("Etc/UTC")
+    end
+  end
+
+  describe "#current_windows_tz" do
+    it "returns the TZ" do
+      expect(resource).to receive(:shell_out).and_return(shellout_tzutil)
+      expect(resource.current_windows_tz).to eql("UTC")
+    end
+  end
+
+  describe "#current_rhel_tz" do
+    it "returns the TZ" do
+      allow(File).to receive(:exist?).with("/etc/sysconfig/clock").and_return true
+      expect(File).to receive(:read).with("/etc/sysconfig/clock").and_return 'ZONE="UTC"'
+      expect(resource.current_rhel_tz).to eql("UTC")
+    end
   end
 end

data/spec/unit/{log_spec.rb → resource/user/windows_user_spec.rb}

@@ -1,5 +1,4 @@
 #
-# Author:: Adam Jacob (<adam@chef.io>)
 # Copyright:: Copyright (c) Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
@@ -16,9 +15,22 @@
 # limitations under the License.
 #
 
-require "tempfile"
-require "logger"
 require "spec_helper"
 
-describe Chef::Log do
+describe Chef::Resource::User::WindowsUser, "#uid" do
+  let(:resource) { Chef::Resource::User::WindowsUser.new("notarealuser") }
+
+  it "allows a string" do
+    resource.uid "100"
+    expect(resource.uid).to eql(100)
+  end
+
+  it "allows an integer" do
+    resource.uid 100
+    expect(resource.uid).to eql(100)
+  end
+
+  it "does not allow a hash" do
+    expect { resource.uid({ woot: "i found it" }) }.to raise_error(ArgumentError)
+  end
 end

data/spec/unit/resource/user_ulimit_spec.rb

@@ -17,7 +17,6 @@
 #
 
 require "spec_helper"
-
 describe Chef::Resource::UserUlimit do
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
@@ -50,4 +49,18 @@ describe Chef::Resource::UserUlimit do
     expect { resource.action :create }.not_to raise_error
     expect { resource.action :delete }.not_to raise_error
   end
+
+  describe "sensitive attribute" do
+    context "should be insensitive by default" do
+      it { expect(resource.sensitive).to(be_falsey) }
+    end
+
+    context "when set" do
+      before { resource.sensitive(true) }
+
+      it "should be set on the resource" do
+        expect(resource.sensitive).to(be_truthy)
+      end
+    end
+  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_certificate_spec.rb

@@ -80,4 +80,16 @@ describe Chef::Resource::WindowsCertificate do
     resource.store_name "MY"
     expect { resource.action :create }.not_to raise_error
   end
+
+  it "the exportable property defaults to false" do
+    expect(resource.exportable).to be false
+  end
+
+  it "doesn't raise error if exportable option is passed" do
+    resource.pfx_password "chef$123"
+    resource.source "C:\\certs\\test-cert.pfx"
+    resource.store_name "MY"
+    resource.exportable true
+    expect { resource.action :create }.not_to raise_error
+  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