chef 17.10.95 → 18.1.0

data/spec/unit/http/authenticator_spec.rb

@@ -19,6 +19,70 @@
 require "spec_helper"
 require "chef/http/authenticator"
 
+describe Chef::HTTP::Authenticator, :windows_only do
+  let(:class_instance) { Chef::HTTP::Authenticator.new(client_name: "test") }
+  let(:method) { "GET" }
+  let(:url) { URI("https://chef.example.com/organizations/test") }
+  let(:headers) { {} }
+  let(:data) { "" }
+  let(:node_name) { "test" }
+  let(:passwrd) { "some_insecure_password" }
+
+  before do
+    Chef::Config[:node_name] = node_name
+    cert_name = "chef-#{node_name}"
+    d = Time.now
+    end_date = Time.new + (3600 * 24 * 90)
+    end_date = end_date.utc.iso8601
+
+    my_client = Chef::Client.new
+    pfx = my_client.generate_pfx_package(cert_name, end_date)
+    my_client.import_pfx_to_store(pfx)
+  end
+
+  after(:each) do
+    require "chef/mixin/powershell_exec"
+    extend Chef::Mixin::PowershellExec
+    cert_name = "chef-#{node_name}"
+    delete_certificate(cert_name)
+  end
+
+  context "when retrieving a certificate from the certificate store" do
+    it "retrieves a certificate password from the registry when the hive does not already exist" do
+      delete_registry_hive
+      expect { class_instance.get_cert_password }.not_to raise_error
+    end
+
+    it "should return a password of at least 14 characters in length" do
+      password = class_instance.get_cert_password
+      expect(password.length).to eql(14)
+    end
+
+    it "correctly retrieves a valid certificate in pem format from the certstore" do
+      require "openssl"
+      certificate = class_instance.retrieve_certificate_key(node_name)
+      cert_object = OpenSSL::PKey::RSA.new(certificate)
+      expect(cert_object.to_s).to match(/BEGIN RSA PRIVATE KEY/)
+    end
+  end
+
+  def delete_certificate(cert_name)
+    powershell_code = <<~CODE
+      Get-ChildItem -path cert:\\LocalMachine\\My -Recurse -Force  | Where-Object { $_.Subject -Match "#{cert_name}" } | Remove-item
+    CODE
+    powershell_exec!(powershell_code)
+  end
+
+  def delete_registry_hive
+    @win32registry = Chef::Win32::Registry.new
+    path = "HKEY_LOCAL_MACHINE\\Software\\Progress\\Authentication"
+    present = @win32registry.get_values(path)
+    unless present.nil? || present.empty?
+      @win32registry.delete_key(path, true)
+    end
+  end
+end
+
 describe Chef::HTTP::Authenticator do
   let(:class_instance) { Chef::HTTP::Authenticator.new(client_name: "test") }
   let(:method) { "GET" }
@@ -26,6 +90,10 @@ describe Chef::HTTP::Authenticator do
   let(:headers) { {} }
   let(:data) { "" }
 
+  before do
+    ::Chef::Config[:node_name] = "foo"
+  end
+
   context "when handle_request is called" do
     shared_examples_for "merging the server API version into the headers" do
       before do

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/property/validation_spec.rb

@@ -600,6 +600,36 @@ describe "Chef::Resource.property validation" do
       it "does not fail if it is not specified, on running the doit2 action" do
         expect { resource.run_action(:doit2) }.not_to raise_error
       end
+
+      context "when an action does not require it" do
+        before do
+          resource.action(:doit2)
+        end
+
+        it "retrieval succeeds if x is not set when resource uses the doit2 action" do
+          expect { resource.x }.not_to raise_error
+        end
+
+        it "succeeds with set to nil when resource uses the doit2 action" do
+          expect { resource.x nil }.not_to raise_error
+        end
+      end
+
+      context "when an action requires it" do
+        before do
+          # NOTE: this is already the default action, but it doesn't
+          # hurt to be clear about the situation.
+          resource.action(:doit)
+        end
+
+        it "if x is not specified, retrieval fails for the doit action" do
+          expect { resource.x }.to raise_error Chef::Exceptions::ValidationFailed
+        end
+
+        it "value nil is not valid for the doit action (required means 'not nil')" do
+          expect { resource.x nil }.to raise_error Chef::Exceptions::ValidationFailed
+        end
+      end
     end
 
     with_property ":x, String, required: true" do

data/spec/unit/provider/cron_spec.rb

@@ -769,6 +769,42 @@ 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

@@ -49,10 +49,6 @@ describe Chef::Provider::Package::Chocolatey, :windows_only do
     allow(provider).to receive(:shell_out_compacted!).with(choco_exe, "list", "-l", "-r", { returns: [0, 2], timeout: timeout }).and_return(local_list_obj)
   end
 
-  after(:each) do
-    described_class.instance_variable_set(:@get_choco_version, nil)
-  end
-
   def allow_remote_list(package_names, args = nil)
     remote_list_stdout = <<~EOF
       Chocolatey v0.9.9.11
@@ -65,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, described_class.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, described_class.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
@@ -82,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(described_class).to receive(:get_choco_version).and_return("1.4.0")
-      expect(provider.query_command).to eql("list")
-    end
-
-    it "Choco V2 uses Search" do
-      allow(described_class).to receive(:get_choco_version).and_return("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"])
@@ -166,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, described_class.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")