chef 17.10.163 → 18.0.169

data/spec/unit/mixin/openssl_helper_spec.rb

@@ -92,7 +92,7 @@ describe Chef::Mixin::OpenSSLHelper do
 
     context "When the dhparam.pem file does exist, and does contain a vaild dhparam key" do
       it "returns true" do
-        @dhparam_file.puts(::OpenSSL::PKey::DH.new(1024).to_pem)
+        @dhparam_file.puts(::OpenSSL::PKey::DH.new(256).to_pem) # this is 256 to speed up specs
         @dhparam_file.close
         expect(instance.dhparam_pem_valid?(@dhparam_file.path)).to be_truthy
       end

data/spec/unit/mixin/powershell_exec_spec.rb

@@ -26,7 +26,7 @@ describe Chef::Mixin::PowershellExec, :windows_only do
   describe "#powershell_exec" do
     context "not specifying an interpreter" do
       it "runs a basic command and returns a Chef::PowerShell object" do
-        expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
+        expect(object.powershell_exec("$PSVersionTable")).to be_kind_of(ChefPowerShell::PowerShell)
       end
 
       it "uses less than version 6" do
@@ -37,7 +37,7 @@ describe Chef::Mixin::PowershellExec, :windows_only do
 
     context "using pwsh interpreter" do
       it "runs a basic command and returns a Chef::PowerShell object" do
-        expect(object.powershell_exec("$PSVersionTable", :pwsh)).to be_kind_of(Chef::Pwsh)
+        expect(object.powershell_exec("$PSVersionTable", :pwsh)).to be_kind_of(ChefPowerShell::Pwsh)
       end
 
       it "uses greater than version 6" do
@@ -48,7 +48,7 @@ describe Chef::Mixin::PowershellExec, :windows_only do
 
     context "using powershell interpreter" do
       it "runs a basic command and returns a Chef::PowerShell object" do
-        expect(object.powershell_exec("$PSVersionTable", :powershell)).to be_kind_of(Chef::PowerShell)
+        expect(object.powershell_exec("$PSVersionTable", :powershell)).to be_kind_of(ChefPowerShell::PowerShell)
       end
 
       it "uses less than version 6" do
@@ -76,11 +76,11 @@ describe Chef::Mixin::PowershellExec, :windows_only do
 
   describe "#powershell_exec!" do
     it "runs a basic command and returns a Chef::PowerShell object" do
-      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(Chef::PowerShell)
+      expect(object.powershell_exec!("$PSVersionTable")).to be_kind_of(ChefPowerShell::PowerShell)
     end
 
     it "raises an error if the command fails" do
-      expect { object.powershell_exec!("this-should-error") }.to raise_error(Chef::PowerShell::CommandFailed)
+      expect { object.powershell_exec!("this-should-error") }.to raise_error(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed)
     end
 
     it "raises an error if the interpreter is invalid" do

data/spec/unit/platform/query_helpers_spec.rb

@@ -18,7 +18,7 @@
 
 require "spec_helper"
 
-describe "Chef::Platform#supports_dsc_invoke_resource?" do
+describe "Chef::Platform#supports_dsc_invoke_resource?", :windows_only do
   it "returns false if powershell is not present" do
     node = Chef::Node.new
     expect(Chef::Platform.supports_dsc_invoke_resource?(node)).to be_falsey
@@ -39,25 +39,10 @@ describe "Chef::Platform#supports_dsc_invoke_resource?" do
   end
 end
 
-describe "Chef::Platform#dsc_refresh_mode_disabled?" do
+describe "Chef::Platform#dsc_refresh_mode_disabled?", :windows_only do
   let(:node) { instance_double("Chef::Node") }
-  let(:powershell) { instance_double("Chef::PowerShell") }
 
   it "returns true when RefreshMode is Disabled" do
-    expect(Chef::PowerShell).to receive(:new)
-      .with("Get-DscLocalConfigurationManager")
-      .and_return(powershell)
-    expect(powershell).to receive(:error!)
-    expect(powershell).to receive(:result).and_return({ "RefreshMode" => "Disabled" })
-    expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be true
-  end
-
-  it "returns false when RefreshMode is not Disabled" do
-    expect(Chef::PowerShell).to receive(:new)
-      .with("Get-DscLocalConfigurationManager")
-      .and_return(powershell)
-    expect(powershell).to receive(:error!)
-    expect(powershell).to receive(:result).and_return({ "RefreshMode" => "LaLaLa" })
     expect(Chef::Platform.dsc_refresh_mode_disabled?(node)).to be false
   end
 end

data/spec/unit/provider/cron_spec.rb

@@ -769,40 +769,6 @@ describe Chef::Provider::Cron do
         end
       end
 
-      context "when integers are provided to the resource to express time values" do
-        it "should not report any difference" do
-          @new_resource.minute(1)
-          @new_resource.hour(1)
-          @new_resource.day(1)
-          @new_resource.month(1)
-          @new_resource.weekday(1)
-          allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
-            # Chef Name: cronhole some stuff
-            1 1 1 1 1 /bin/true
-          CRONTAB
-
-          @provider.run_action(:create)
-          expect(@new_resource).not_to be_updated_by_last_action
-        end
-      end
-
-      context "when strings are provided to the resource to express time values" do
-        it "should not report any difference" do
-          @new_resource.minute("1")
-          @new_resource.hour("1")
-          @new_resource.day("1")
-          @new_resource.month("1")
-          @new_resource.weekday("1")
-          allow(@provider).to receive(:read_crontab).and_return(<<~CRONTAB)
-            # Chef Name: cronhole some stuff
-            1 1 1 1 1 /bin/true
-          CRONTAB
-
-          @provider.run_action(:create)
-          expect(@new_resource).not_to be_updated_by_last_action
-        end
-      end
-
       context "when environment variable is used" do
         before :each do
           @provider.cron_exists = true

data/spec/unit/provider/http_request_spec.rb

@@ -19,87 +19,75 @@
 require "spec_helper"
 
 describe Chef::Provider::HttpRequest do
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::HttpRequest.new("adam")
-    @new_resource.name "adam"
-    @new_resource.url "http://www.opscode.com/"
-    @new_resource.message "is cool"
-
-    @provider = Chef::Provider::HttpRequest.new(@new_resource, @run_context)
-  end
-
-  describe "load_current_resource" do
-
-    it "should set up a Chef::ServerAPI client, with no authentication" do
-      expect(Chef::HTTP::Simple).to receive(:new).with(@new_resource.url)
-      @provider.load_current_resource
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:new_resource) do
+    Chef::Resource::HttpRequest.new("adam").tap do |new_resource|
+      new_resource.name "adam"
+      new_resource.url "http://www.opscode.com/"
+      new_resource.message "is cool"
     end
   end
 
+  let(:provider) { Chef::Provider::HttpRequest.new(new_resource, run_context) }
+
   describe "when making REST calls" do
-    before(:each) do
-      # run_action(x) forces load_current_resource to run;
-      # that would overwrite our supplied mock Chef::Rest # object
-      allow(@provider).to receive(:load_current_resource).and_return(true)
-      @http = double("Chef::ServerAPI")
-      @provider.http = @http
+    let(:http) do
+      provider.http = double("Chef::ServerAPI")
     end
 
     describe "action_get" do
 
       it "should inflate a message block at runtime" do
-        @new_resource.message { "return" }
-        expect(@http).to receive(:get).with("http://www.opscode.com/", {})
-        @provider.run_action(:get)
-        expect(@new_resource).to be_updated
+        new_resource.message { "return" }
+        expect(http).to receive(:get).with("http://www.opscode.com/", {})
+        provider.run_action(:get)
+        expect(new_resource).to be_updated
       end
 
       it "should run a GET request" do
-        expect(@http).to receive(:get).with("http://www.opscode.com/", {})
-        @provider.run_action(:get)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:get).with("http://www.opscode.com/", {})
+        provider.run_action(:get)
+        expect(new_resource).to be_updated
       end
     end
 
     describe "action_put" do
       it "should run a PUT request with the message as the payload" do
-        expect(@http).to receive(:put).with("http://www.opscode.com/", @new_resource.message, {})
-        @provider.run_action(:put)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:put).with("http://www.opscode.com/", new_resource.message, {})
+        provider.run_action(:put)
+        expect(new_resource).to be_updated
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.message(lambda { "return" })
-        expect(@http).to receive(:put).with("http://www.opscode.com/", "return", {})
-        @provider.run_action(:put)
-        expect(@new_resource).to be_updated
+        new_resource.message(lambda { "return" })
+        expect(http).to receive(:put).with("http://www.opscode.com/", "return", {})
+        provider.run_action(:put)
+        expect(new_resource).to be_updated
       end
     end
 
     describe "action_post" do
       it "should run a PUT request with the message as the payload" do
-        expect(@http).to receive(:post).with("http://www.opscode.com/", @new_resource.message, {})
-        @provider.run_action(:post)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:post).with("http://www.opscode.com/", new_resource.message, {})
+        provider.run_action(:post)
+        expect(new_resource).to be_updated
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.message { "return" }
-        expect(@http).to receive(:post).with("http://www.opscode.com/", "return", {})
-        @provider.run_action(:post)
-        expect(@new_resource).to be_updated
+        new_resource.message { "return" }
+        expect(http).to receive(:post).with("http://www.opscode.com/", "return", {})
+        provider.run_action(:post)
+        expect(new_resource).to be_updated
       end
     end
 
     describe "action_delete" do
       it "should run a DELETE request" do
-        expect(@http).to receive(:delete).with("http://www.opscode.com/", {})
-        @provider.run_action(:delete)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:delete).with("http://www.opscode.com/", {})
+        provider.run_action(:delete)
+        expect(new_resource).to be_updated
       end
     end
 
@@ -107,52 +95,52 @@ describe Chef::Provider::HttpRequest do
     # and false for a "304 Not Modified" response
     describe "action_head" do
       before do
-        @provider.http = @http
+        provider.http = http
       end
 
       it "should inflate a message block at runtime" do
-        @new_resource.message { "return" }
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        new_resource.message { "return" }
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should run a HEAD request" do
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should update a HEAD request with empty string response body (CHEF-4762)" do
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return("")
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return("")
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should update a HEAD request with nil response body (CHEF-4762)" do
-        expect(@http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
-        @provider.run_action(:head)
-        expect(@new_resource).to be_updated
+        expect(http).to receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
+        provider.run_action(:head)
+        expect(new_resource).to be_updated
       end
 
       it "should not update a HEAD request if a not modified response (CHEF-4762)" do
         if_modified_since = File.mtime(__FILE__).httpdate
-        @new_resource.headers "If-Modified-Since" => if_modified_since
-        expect(@http).to receive(:head).with("http://www.opscode.com/", { "If-Modified-Since" => if_modified_since }).and_return(false)
-        @provider.run_action(:head)
-        expect(@new_resource).not_to be_updated
+        new_resource.headers "If-Modified-Since" => if_modified_since
+        expect(http).to receive(:head).with("http://www.opscode.com/", { "If-Modified-Since" => if_modified_since }).and_return(false)
+        provider.run_action(:head)
+        expect(new_resource).not_to be_updated
       end
 
       it "should run a HEAD request with If-Modified-Since header" do
-        @new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
-        expect(@http).to receive(:head).with("http://www.opscode.com/", @new_resource.headers)
-        @provider.run_action(:head)
+        new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
+        expect(http).to receive(:head).with("http://www.opscode.com/", new_resource.headers)
+        provider.run_action(:head)
       end
 
       it "doesn't call converge_by if HEAD does not return modified" do
-        expect(@http).to receive(:head).and_return(false)
-        expect(@provider).not_to receive(:converge_by)
-        @provider.run_action(:head)
+        expect(http).to receive(:head).and_return(false)
+        expect(provider).not_to receive(:converge_by)
+        provider.run_action(:head)
       end
     end
   end

data/spec/unit/provider/mount/linux_spec.rb

@@ -25,6 +25,7 @@ describe Chef::Provider::Mount::Linux do
     allow(::File).to receive(:exists?).with("/dev/sdz1").and_return true
     allow(::File).to receive(:exists?).with("/tmp/foo").and_return true
     allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup").and_return true
+    allow(::File).to receive(:exists?).with("//192.168.11.102/Share/backup folder").and_return true
     allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
     allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
   end
@@ -103,6 +104,15 @@ describe Chef::Provider::Mount::Linux do
       provider.load_current_resource
       expect(provider.current_resource.mounted).to be_truthy
     end
+
+    it "should set mounted true if device name has a space and the mount point is found in the mounts list" do
+      new_resource.device "//192.168.11.102/Share/backup folder"
+      new_resource.fstype "cifs"
+      mount = "/tmp/foo //192.168.11.102/Share/backup\x20folder cifs rw\n"
+      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
+      provider.load_current_resource
+      expect(provider.current_resource.mounted).to be_truthy
+    end
   end
 
   context "to check if loop resource is mounted" do

data/spec/unit/provider/package/chocolatey_spec.rb

@@ -47,11 +47,6 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     allow(provider).to receive(:choco_exe).and_return(choco_exe)
     local_list_obj = double(stdout: local_list_stdout)
     allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-l", "-r", { returns: [0, 2], timeout: timeout }).and_return(local_list_obj)
-    allow(provider).to receive(:powershell_exec!).with("#{choco_exe} --version").and_return(double(result: "2.1.0"))
-  end
-
-  after(:each) do
-    provider.instance_variable_set(:@get_choco_version, nil)
   end
 
   def allow_remote_list(package_names, args = nil)
@@ -66,9 +61,9 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     remote_list_obj = double(stdout: remote_list_stdout)
     package_names.each do |pkg|
       if args
-        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, provider.query_command, "-r", pkg, *args, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
+        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-r", pkg, *args, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
       else
-        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, provider.query_command, "-r", pkg, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
+        allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-r", pkg, { returns: [0, 2], timeout: timeout }).and_return(remote_list_obj)
       end
     end
   end
@@ -83,18 +78,6 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     end
   end
 
-  describe "choco searches change with the version" do
-    it "Choco V1 uses List" do
-      allow(provider).to receive(:powershell_exec!).with("#{choco_exe} --version").and_return(double(result: "1.4.0"))
-      expect(provider.query_command).to eql("list")
-    end
-
-    it "Choco V2 uses Search" do
-      allow(provider).to receive(:powershell_exec!).with("#{choco_exe} --version").and_return(double(result: "2.1.0"))
-      expect(provider.query_command).to eql("search")
-    end
-  end
-
   describe "#candidate_version" do
     it "should set the candidate_version to the latest version when not pinning" do
       allow_remote_list(["git"])
@@ -167,7 +150,7 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
       new_resource.package_name("package-does-not-exist")
       new_resource.returns([0])
       allow(provider).to receive(:shell_out_compacted!)
-        .with(choco_exe, provider.query_command, "-r", new_resource.package_name.first, { returns: new_resource.returns, timeout: timeout })
+        .with(choco_exe, "list", "-r", new_resource.package_name.first, { returns: new_resource.returns, timeout: timeout })
         .and_raise(Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with [0], but received '2'")
       expect { provider.send(:available_packages) }.to raise_error(Mixlib::ShellOut::ShellCommandFailed, "Expected process to exit with [0], but received '2'")
     end

data/spec/unit/provider/package/rubygems_spec.rb

@@ -139,7 +139,7 @@ describe Chef::Provider::Package::Rubygems::CurrentGemEnvironment do
         .to_return(status: 200, body: "", headers: {})
       stub_request(:get, "https://rubygems2.org/info/sexp_processor")
         .to_return(status: 200, body: File.binread(File.join(CHEF_SPEC_DATA, "rubygems.org", "sexp_processor-info")))
-      stub_request(:get, "https://rubygems2.org/quick/Marshal.4.8/sexp_processor-4.15.1.gemspec.rz")
+      stub_request(:get, "https://rubygems2.org/quick/Marshal.4.8/sexp_processor-4.16.1.gemspec.rz")
         .to_return(status: 200, body: File.binread(File.join(CHEF_SPEC_DATA, "rubygems.org", "sexp_processor-4.15.1.gemspec.rz")))
 
       dep = Gem::Dependency.new("sexp_processor", ">= 0")

data/spec/unit/provider/package/zypper_spec.rb

@@ -32,6 +32,8 @@ describe Chef::Provider::Package::Zypper do
 
   let(:status) { double(stdout: "\n", exitstatus: 0) }
 
+  let(:source) { "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm" }
+
   before(:each) do
     allow(Chef::Resource::Package).to receive(:new).and_return(current_resource)
     allow(provider).to receive(:shell_out_compacted!).and_return(status)
@@ -163,6 +165,21 @@ describe Chef::Provider::Package::Zypper do
       )
       provider.install_package(["emacs"], ["1.0"])
     end
+
+    it "should run zypper install with source option" do
+      new_resource.source "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with("/tmp/wget_1.11.4-1ubuntu1_amd64.rpm").and_return(true)
+      shell_out_expectation!(
+        "zypper", "--non-interactive", "install", "--auto-agree-with-licenses", "--oldpackage", "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      )
+      provider.install_package(["wget"], ["1.11.4-1ubuntu1_amd64"])
+    end
+
+    it "should raise an exception if a source is supplied but not found when :install" do
+      new_resource.source "/tmp/blah/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with(new_resource.source).and_return(false)
+      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
+    end
   end
 
   describe "upgrade_package" do
@@ -200,6 +217,21 @@ describe Chef::Provider::Package::Zypper do
       )
       provider.upgrade_package(["emacs"], ["1.0"])
     end
+
+    it "should run zypper upgrade with source option" do
+      new_resource.source "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with("/tmp/wget_1.11.4-1ubuntu1_amd64.rpm").and_return(true)
+      shell_out_expectation!(
+        "zypper", "--non-interactive", "install", "--auto-agree-with-licenses", "--oldpackage", "/tmp/wget_1.11.4-1ubuntu1_amd64.rpm"
+      )
+      provider.upgrade_package(["wget"], ["1.11.4-1ubuntu1_amd64"])
+    end
+
+    it "should raise an exception if a source is supplied but not found when :upgrade" do
+      new_resource.source "/tmp/blah/wget_1.11.4-1ubuntu1_amd64.rpm"
+      allow(::File).to receive(:exist?).with(new_resource.source).and_return(false)
+      expect { provider.run_action(:upgrade) }.to raise_error(Chef::Exceptions::Package)
+    end
   end
 
   describe "remove_package" do

data/spec/unit/provider/user/linux_spec.rb

@@ -20,7 +20,7 @@
 
 require "spec_helper"
 
-describe Chef::Provider::User::Linux do
+describe Chef::Provider::User::Linux, linux_only: true do
 
   subject(:provider) do
     p = described_class.new(@new_resource, @run_context)
@@ -71,6 +71,56 @@ describe Chef::Provider::User::Linux do
     end
   end
 
+  describe "expire_date behavior" do
+    before(:each) do
+      @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+      @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+    end
+
+    it "defaults expire_date to nil" do
+      expect( @new_resource.expire_date ).to be nil
+    end
+
+    it "by default expire_date is nil and we use ''" do
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting expire_date to nil includes ''" do
+      @new_resource.expire_date nil
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting expire_date to 1982-04-16 includes -e" do
+      @new_resource.expire_date "1982-04-16"
+      expect( provider.universal_options ).to eql(["-e", "1982-04-16"])
+    end
+  end
+
+  describe "inactive behavior" do
+    before(:each) do
+      @new_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+      @current_resource = Chef::Resource::User::LinuxUser.new("adam", @run_context)
+    end
+
+    it "defaults inactive to nil" do
+      expect( @new_resource.inactive ).to be nil
+    end
+
+    it "by default inactive is nil and we use ''" do
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting inactive to nil includes ''" do
+      @new_resource.inactive nil
+      expect( provider.universal_options ).to eql([])
+    end
+
+    it "setting inactive to 90 includes -f" do
+      @new_resource.inactive 90
+      expect( provider.universal_options ).to eql(["-f", 90])
+    end
+  end
+
   describe "compare_user_linux" do
     before(:each) do
       @new_resource = Chef::Resource::User::LinuxUser.new("notarealuser")
@@ -86,7 +136,6 @@ describe Chef::Provider::User::Linux do
         "home" => ["/home/notarealuser", "/Users/notarealuser"],
         "shell" => ["/usr/bin/zsh", "/bin/bash"],
         "password" => %w{abcd 12345},
-        "sensitive" => [true],
       }
     end
 
@@ -98,15 +147,6 @@ describe Chef::Provider::User::Linux do
       end
     end
 
-    it "should show a blank for password if sensitive set to true" do
-      @new_resource.password mapping["password"][0]
-      @current_resource.password mapping["password"][1]
-      @new_resource.sensitive true
-      @current_resource.sensitive true
-      provider.compare_user
-      expect(provider.change_desc).to eql(["change password from ******** to ********"])
-    end
-
     %w{uid gid}.each do |property|
       it "should return false if string #{property} matches fixnum" do
         @new_resource.send(property, "100")

data/spec/unit/provider/user_spec.rb

@@ -178,12 +178,30 @@ describe Chef::Provider::User do
         end
       end
 
-      it "should fail assertions when ruby-shadow cannot be loaded" do
-        expect(@provider).to receive(:require).with("shadow") { raise LoadError }
-        @provider.load_current_resource
-        @provider.action = :create
-        @provider.define_resource_requirements
-        expect { @provider.process_resource_requirements }.to raise_error Chef::Exceptions::MissingLibrary
+      context "when ruby-shadow is supported on the platform" do
+        before do
+          allow(@provider).to receive(:supports_ruby_shadow?).and_return true
+        end
+        it "should fail assertions when ruby-shadow cannot be loaded" do
+          expect(@provider).to receive(:require).with("shadow") { raise LoadError }
+          @provider.load_current_resource
+          @provider.action = :create
+          @provider.define_resource_requirements
+          expect { @provider.process_resource_requirements }.to raise_error Chef::Exceptions::MissingLibrary
+        end
+      end
+
+      context "when ruby-shadow is not supported on the platform" do
+        before do
+          allow(@provider).to receive(:supports_ruby_shadow?).and_return false
+        end
+        it "should not fail any assertions when ruby-shadow cannot be loaded" do
+          expect(@provider).to receive(:require).with("shadow") { raise LoadError }
+          @provider.load_current_resource
+          @provider.action = :create
+          @provider.define_resource_requirements
+          @provider.process_resource_requirements
+        end
       end
 
     end

data/spec/unit/resource/archive_file_spec.rb

@@ -29,7 +29,7 @@ rescue LoadError
   end
 end
 
-describe Chef::Resource::ArchiveFile, :not_supported_on_aix do
+describe Chef::Resource::ArchiveFile, :not_supported_on_aix, :not_supported_on_windows do
   let(:node) { Chef::Node.new }
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }

data/spec/unit/resource/chef_client_cron_spec.rb

@@ -43,6 +43,11 @@ describe Chef::Resource::ChefClientCron do
     expect { resource.splay("-10") }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "set splay to 0" do
+    resource.splay "0"
+    expect(resource.splay).to eql(0)
+  end
+
   it "builds a default value for chef_binary_path dist values" do
     expect(resource.chef_binary_path).to eql("/opt/chef/bin/chef-client")
   end

data/spec/unit/resource/chef_client_launchd_spec.rb

@@ -43,6 +43,11 @@ describe Chef::Resource::ChefClientLaunchd do
     expect { resource.splay("-10") }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "set splay to 0" do
+    resource.splay "0"
+    expect(resource.splay).to eql(0)
+  end
+
   it "builds a default value for chef_binary_path dist values" do
     expect(resource.chef_binary_path).to eql("/opt/chef/bin/chef-client")
   end

data/spec/unit/resource/chef_client_scheduled_task_spec.rb

@@ -43,6 +43,11 @@ describe Chef::Resource::ChefClientScheduledTask do
     expect { resource.splay("-10") }.to raise_error(Chef::Exceptions::ValidationFailed)
   end
 
+  it "set splay to 0" do
+    resource.splay "0"
+    expect(resource.splay).to eql(0)
+  end
+
   it "coerces frequency_modifier to an Integer" do
     resource.frequency_modifier "10"
     expect(resource.frequency_modifier).to eql(10)

data/spec/unit/resource/chef_client_systemd_timer_spec.rb

@@ -102,7 +102,7 @@ describe Chef::Resource::ChefClientSystemdTimer do
 
     it "sets CPUQuota if cpu_quota property is set" do
       resource.cpu_quota 50
-      expect(provider.service_content["Service"]["CPUQuota"]).to eq("50%")
+      expect(provider.service_content["Service"]["CPUQuota"]).to eq(50)
     end
   end
-end
+end