chef 17.10.163 → 18.0.185

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

@@ -47,8 +47,6 @@ describe Chef::Mixin::HomebrewUser do
     let(:user) { nil }
     let(:brew_owner) { 2001 }
     let(:default_brew_path) { "/usr/local/bin/brew" }
-    let(:default_brew_path_arm) { "/opt/homebrew/bin/brew" }
-    let(:default_brew_path_linux) { "/home/linuxbrew/.linuxbrew/bin/brew" }
     let(:stat_double) do
       d = double
       expect(d).to receive(:uid).and_return(brew_owner)
@@ -61,38 +59,16 @@ describe Chef::Mixin::HomebrewUser do
         expect(Etc).to receive(:getpwuid).with(brew_owner).and_return(OpenStruct.new(name: "name"))
       end
 
-      def false_unless_specific_value(object, method, value)
-        allow(object).to receive(method).and_return(false)
-        allow(object).to receive(method).with(value).and_return(true)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for x86_64 machines" do
-        false_unless_specific_value(File, :exist?, default_brew_path)
-        false_unless_specific_value(File, :executable?, default_brew_path)
-        allow(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
-        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for arm machines" do
-        false_unless_specific_value(File, :exist?, default_brew_path_arm)
-        false_unless_specific_value(File, :executable?, default_brew_path_arm)
-        allow(File).to receive(:stat).with(default_brew_path_arm).and_return(stat_double)
-        expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
-      end
-
-      it "returns the owner of the brew executable when it is at a default location for linux machines" do
-        false_unless_specific_value(File, :exist?, default_brew_path_linux)
-        false_unless_specific_value(File, :executable?, default_brew_path_linux)
-        allow(File).to receive(:stat).with(default_brew_path_linux).and_return(stat_double)
+      it "returns the owner of the brew executable when it is at a default location" do
+        expect(File).to receive(:exist?).with(default_brew_path).and_return(true)
+        expect(File).to receive(:stat).with(default_brew_path).and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
       it "returns the owner of the brew executable when it is not at a default location" do
-        allow_any_instance_of(ExampleHomebrewUser).to receive(:which).and_return("/foo")
-        false_unless_specific_value(File, :exist?, "/foo")
-        false_unless_specific_value(File, :executable?, "/foo")
+        expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
         allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("/foo")
-        allow(File).to receive(:stat).with("/foo").and_return(stat_double)
+        expect(File).to receive(:stat).with("/foo").and_return(stat_double)
         expect(homebrew_user.find_homebrew_uid(user)).to eq(brew_owner)
       end
 
@@ -102,7 +78,8 @@ describe Chef::Mixin::HomebrewUser do
   describe "when the homebrew user is not provided" do
 
     it "raises an error if no executable is found" do
-      expect(File).to receive(:exist?).and_return(nil).at_least(:once)
+      expect(File).to receive(:exist?).with(default_brew_path).and_return(false)
+      allow(homebrew_user).to receive_message_chain(:shell_out, :stdout, :strip).and_return("")
       expect { homebrew_user.find_homebrew_uid(user) }.to raise_error(Chef::Exceptions::CannotDetermineHomebrewOwner)
     end
 

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

@@ -779,6 +779,7 @@ describe Chef::Provider::Cron do
           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)
@@ -796,6 +797,7 @@ describe Chef::Provider::Cron do
           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)

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