chef 12.5.1 → 12.6.0

data/spec/unit/property_spec.rb

@@ -921,6 +921,9 @@ describe "Chef::Resource.property" do
         expect(resource.x 10).to eq "101"
         expect(Namer.current_index).to eq 1
       end
+      it "does not emit a deprecation warning if set to nil" do
+        expect(resource.x nil).to eq "1"
+      end
       it "coercion sets the value (and coercion does not run on get)" do
         expect(resource.x 10).to eq "101"
         expect(resource.x).to eq "101"
@@ -933,6 +936,11 @@ describe "Chef::Resource.property" do
         expect(Namer.current_index).to eq 2
       end
     end
+    with_property ':x, coerce: proc { |x| x }' do
+      it "does not emit a deprecation warning if set to nil" do
+        expect(resource.x nil).to be_nil
+      end
+    end
     with_property ':x, coerce: proc { |x| Namer.next_index; raise "hi" if x == 10; x }, is: proc { |x| Namer.next_index; x != 10 }' do
       it "failed coercion fails to set the value" do
         resource.x 20
@@ -1091,4 +1099,52 @@ describe "Chef::Resource.property" do
     expect { resource_class.property :x, :name_property => true, :name_attribute => true }.to raise_error ArgumentError,
       /Cannot specify both name_property and name_attribute together on property x of resource chef_resource_property_spec_(\d+)./
   end
+
+  context "with a custom property type" do
+    class CustomPropertyType < Chef::Property
+    end
+
+    with_property ":x, CustomPropertyType.new" do
+      it "creates x with the given type" do
+        expect(resource_class.properties[:x]).to be_kind_of(CustomPropertyType)
+      end
+
+      context "and a subclass" do
+        let(:subresource_class) do
+          new_resource_name = self.class.new_resource_name
+          Class.new(resource_class) do
+            resource_name new_resource_name
+          end
+        end
+        let(:subresource) do
+          subresource_class.new('blah')
+        end
+
+        context "with property :x, default: 10 on the subclass" do
+          before do
+            subresource_class.class_eval do
+              property :x, default: 10
+            end
+          end
+
+          it "x has the given type and default on the subclass" do
+            expect(subresource_class.properties[:x]).to be_kind_of(CustomPropertyType)
+            expect(subresource_class.properties[:x].default).to eq(10)
+          end
+
+          it "x does not have the default on the superclass" do
+            expect(resource_class.properties[:x]).to be_kind_of(CustomPropertyType)
+            expect(resource_class.properties[:x].default).to be_nil
+          end
+        end
+      end
+    end
+
+    with_property ":x, CustomPropertyType.new, default: 10" do
+      it "passes the default to the custom property type" do
+        expect(resource_class.properties[:x]).to be_kind_of(CustomPropertyType)
+        expect(resource_class.properties[:x].default).to eq(10)
+      end
+    end
+  end
 end

data/spec/unit/provider/deploy_spec.rb

@@ -356,7 +356,7 @@ describe Chef::Provider::Deploy do
   it "chowns the whole release dir to user and group specified in the resource" do
     @resource.user "foo"
     @resource.group "bar"
-    expect(FileUtils).to receive(:chown_R).with("foo", "bar", "/my/deploy/dir")
+    expect(FileUtils).to receive(:chown_R).with("foo", "bar", "/my/deploy/dir", { :force => true })
     @provider.enforce_ownership
   end
 

data/spec/unit/provider/dsc_resource_spec.rb

@@ -16,7 +16,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 require 'chef'
 require 'spec_helper'
 
@@ -34,7 +33,6 @@ describe Chef::Provider::DscResource do
       node.automatic[:languages][:powershell][:version] = '4.0'
       node
     }
-
     it 'raises a ProviderNotFound exception' do
       expect(provider).not_to receive(:meta_configuration)
       expect{provider.run_action(:run)}.to raise_error(
@@ -43,35 +41,76 @@ describe Chef::Provider::DscResource do
   end
 
   context 'when Powershell supports Invoke-DscResource' do
+
+    context 'when RefreshMode is not set to Disabled' do
+      context 'and the WMF 5 is a preview release' do
+        let (:node) {
+          node = Chef::Node.new
+          node.automatic[:languages][:powershell][:version] = '5.0.10018.0'
+          node
+        }
+        it 'raises an exception' do
+          expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(false)
+          expect { provider.run_action(:run) }.to raise_error(
+            Chef::Exceptions::ProviderNotFound, /Disabled/)
+        end
+      end
+      context 'and the WMF is 5 RTM or newer' do
+        let (:node) {
+          node = Chef::Node.new
+          node.automatic[:languages][:powershell][:version] = '5.0.10586.0'
+          node
+        }
+        it 'does not raises an exception' do
+          expect(provider).to receive(:test_resource)
+          expect(provider).to receive(:set_resource)
+          expect(provider).to receive(:reboot_if_required)
+          expect { provider.run_action(:run) }.to_not raise_error
+        end
+      end
+    end
+  end
+  
+  context 'when the LCM supports Invoke-DscResource' do
     let (:node) {
       node = Chef::Node.new
       node.automatic[:languages][:powershell][:version] = '5.0.10018.0'
       node
     }
 
-    context 'when RefreshMode is not set to Disabled' do
-      it 'raises an exception' do
-        expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(false)
-        expect { provider.run_action(:run) }.to raise_error(
-          Chef::Exceptions::ProviderNotFound, /Disabled/)
-      end
+    it 'does not update the resource if it is up to date' do
+      expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
+      expect(provider).to receive(:test_resource).and_return(true)
+      provider.run_action(:run)
+      expect(resource).not_to be_updated
     end
 
-    context 'when RefreshMode is set to Disabled' do
-      it 'does not update the resource if it is up to date' do
-        expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
-        expect(provider).to receive(:test_resource).and_return(true)
-        provider.run_action(:run)
-        expect(resource).not_to be_updated
-      end
-
-      it 'converges the resource if it is not up to date' do
-        expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
-        expect(provider).to receive(:test_resource).and_return(false)
-        expect(provider).to receive(:set_resource)
-        provider.run_action(:run)
-        expect(resource).to be_updated
-      end
+    it 'converges the resource if it is not up to date' do
+      expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
+      expect(provider).to receive(:test_resource).and_return(false)
+      expect(provider).to receive(:set_resource)
+      provider.run_action(:run)
+      expect(resource).to be_updated
+    end
+    
+    it 'flags the resource as reboot required when required' do
+      expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
+      expect(provider).to receive(:test_resource).and_return(false)
+      expect(provider).to receive(:invoke_resource).
+        and_return(double(:stdout => '', :return_value =>nil))
+      expect(provider).to receive(:return_dsc_resource_result).and_return(true)
+      expect(provider).to receive(:create_reboot_resource)
+      provider.run_action(:run)
+    end
+    
+    it 'does not flag the resource as reboot required when not required' do
+      expect(provider).to receive(:dsc_refresh_mode_disabled?).and_return(true)
+      expect(provider).to receive(:test_resource).and_return(false)
+      expect(provider).to receive(:invoke_resource).
+        and_return(double(:stdout => '', :return_value =>nil))
+      expect(provider).to receive(:return_dsc_resource_result).and_return(false)
+      expect(provider).to_not receive(:create_reboot_resource)
+      provider.run_action(:run)
     end
   end
-end
+end

data/spec/unit/provider/execute_spec.rb

@@ -25,28 +25,32 @@ describe Chef::Provider::Execute do
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:provider) { Chef::Provider::Execute.new(new_resource, run_context) }
   let(:current_resource) { Chef::Resource::Ifconfig.new("foo_resource", run_context) }
+  # You will be the same object, I promise.
+  @live_stream = Chef::EventDispatch::EventsOutputStream.new(run_context.events, :name => :execute)
 
   let(:opts) do
     {
       timeout:      3600,
       returns:      0,
       log_level:    :info,
-      log_tag:      new_resource.to_s,
-      live_stream:  STDOUT,
+      log_tag:      new_resource.to_s
     }
   end
 
   let(:new_resource) { Chef::Resource::Execute.new("foo_resource", run_context) }
 
   before do
+    allow(Chef::EventDispatch::EventsOutputStream).to receive(:new) { @live_stream }
     allow(ChefConfig).to receive(:windows?) { false }
     @original_log_level = Chef::Log.level
     Chef::Log.level = :info
-    allow(STDOUT).to receive(:tty?).and_return(true)
+    allow(STDOUT).to receive(:tty?).and_return(false)
   end
 
   after do
     Chef::Log.level = @original_log_level
+    Chef::Config[:always_stream_execute] = false
+    Chef::Config[:daemon] = false
   end
 
   describe "#initialize" do
@@ -142,35 +146,98 @@ describe Chef::Provider::Execute do
       expect(new_resource).not_to be_updated
     end
 
-    it "should unset the live_stream if STDOUT is not a tty" do
-      expect(STDOUT).to receive(:tty?).and_return(false)
+    it "should not include stdout/stderr in failure exception for sensitive resource" do
       opts.delete(:live_stream)
-      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-      expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
+      new_resource.sensitive true
+      expect(provider).to receive(:shell_out!).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect do
+        provider.run_action(:run)
+      end.to raise_error(Mixlib::ShellOut::ShellCommandFailed, /suppressed for sensitive resource/)
     end
 
-    it "should unset the live_stream if chef is running as a daemon" do
-      allow(Chef::Config).to receive(:[]).and_call_original
-      expect(Chef::Config).to receive(:[]).with(:daemon).and_return(true)
-      opts.delete(:live_stream)
-      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-      expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
-    end
+    describe "streaming output" do
+      it "should not set the live_stream if sensitive is on" do
+        new_resource.sensitive true
+        expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+        expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+        expect(Chef::Log).not_to receive(:warn)
+        provider.run_action(:run)
+        expect(new_resource).to be_updated
+      end
 
-    it "should unset the live_stream if we are not running with a log level of at least :info" do
-      expect(Chef::Log).to receive(:info?).and_return(false)
-      opts.delete(:live_stream)
-      expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
-      expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
-      expect(Chef::Log).not_to receive(:warn)
-      provider.run_action(:run)
-      expect(new_resource).to be_updated
+      describe "with an output formatter listening" do
+        let(:events) { d = Chef::EventDispatch::Dispatcher.new; d.register(Chef::Formatters::Doc.new(StringIO.new, StringIO.new)); d }
+
+        before do
+          Chef::Config[:stream_execute_output] = true
+        end
+
+        it "should set the live_stream if the log level is info or above" do
+          nopts = opts
+          nopts[:live_stream] = @live_stream
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should set the live_stream if the resource requests live streaming" do
+          Chef::Log.level = :warn
+          new_resource.live_stream true
+          nopts = opts
+          nopts[:live_stream] = @live_stream
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should not set the live_stream if the resource is sensitive" do
+          new_resource.sensitive true
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+          expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+      end
+
+      describe "with only logging enabled" do
+        it "should set the live_stream to STDOUT if we are a TTY, not daemonized, not sensitive, and info is enabled" do
+          nopts = opts
+          nopts[:live_stream] = STDOUT
+          allow(STDOUT).to receive(:tty?).and_return(true)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, nopts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should not set the live_stream to STDOUT if we are a TTY, not daemonized, but sensitive" do
+          new_resource.sensitive true
+          allow(STDOUT).to receive(:tty?).and_return(true)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+          expect(provider).to receive(:converge_by).with("execute sensitive resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+        it "should not set the live_stream to STDOUT if we are a TTY, but daemonized" do
+          Chef::Config[:daemon] = true
+          allow(STDOUT).to receive(:tty?).and_return(true)
+          expect(provider).to receive(:shell_out!).with(new_resource.name, opts)
+          expect(provider).to receive(:converge_by).with("execute foo_resource").and_call_original
+          expect(Chef::Log).not_to receive(:warn)
+          provider.run_action(:run)
+          expect(new_resource).to be_updated
+        end
+
+      end
     end
+
   end
 end

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

@@ -1,4 +1,3 @@
-#
 # Author:: Bryan McLellan (btm@loftninjas.org)
 # Copyright:: Copyright (c) 2009 Bryan McLellan
 # License:: Apache License, Version 2.0
@@ -19,42 +18,109 @@
 require 'spec_helper'
 
 describe Chef::Provider::Package::Dpkg do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:package) { "wget" }
+  let(:source) { "/tmp/wget_1.11.4-1ubuntu1_amd64.deb" }
+  let(:new_resource) do
+    new_resource = Chef::Resource::DpkgPackage.new(package)
+    new_resource.source source
+    new_resource
+  end
+  let(:provider) { Chef::Provider::Package::Dpkg.new(new_resource, run_context) }
+
+  let(:dpkg_deb_version) { "1.11.4" }
+  let(:dpkg_deb_status) { status = double(:stdout => "#{package}\t#{dpkg_deb_version}", :exitstatus => 0) }
+  let(:dpkg_s_version) { "1.11.4-1ubuntu1" }
+  let(:dpkg_s_status) do
+    stdout = <<-DPKG_S
+Package: #{package}
+Status: install ok installed
+Priority: important
+Section: web
+Installed-Size: 1944
+Maintainer: Ubuntu Core developers <ubuntu-devel-discuss@lists.ubuntu.com>
+Architecture: amd64
+Version: #{dpkg_s_version}
+Config-Version: #{dpkg_s_version}
+Depends: libc6 (>= 2.8~20080505), libssl0.9.8 (>= 0.9.8f-5)
+Conflicts: wget-ssl
+    DPKG_S
+    status = double(:stdout => stdout, :exitstatus => 1)
+  end
+
   before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Package.new("wget")
-    @new_resource.source "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+    allow(provider).to receive(:shell_out!).with("dpkg-deb -W #{source}", timeout: 900).and_return(dpkg_deb_status)
+    allow(provider).to receive(:shell_out!).with("dpkg -s #{package}", timeout: 900, returns: [0,1]).and_return(double(stdout: "", exitstatus: 1))
+    allow(::File).to receive(:exist?).with(source).and_return(true)
+  end
 
-    @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
+  describe "#define_resource_requirements" do
+    it "should raise an exception if a source is supplied but not found when :install" do
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should raise an exception if a source is supplied but not found when :upgrade" do
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect { provider.run_action(:upgrade) }.to raise_error(Chef::Exceptions::Package)
+    end
 
-    @status = double(:stdout => "", :exitstatus => 0)
-    allow(@provider).to receive(:shell_out).and_return(@status)
+    # FIXME?  we're saying we ignore source, but should supplying source on :remove or :purge be an actual error?
+    it "should not raise an exception if a source is supplied but not found when :remove" do
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect(provider).to receive(:action_remove)
+      expect { provider.run_action(:remove) }.not_to raise_error
+    end
 
-    allow(::File).to receive(:exists?).and_return(true)
+    it "should not raise an exception if a source is supplied but not found when :purge" do
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect(provider).to receive(:action_purge)
+      expect { provider.run_action(:purge) }.not_to raise_error
+    end
+
+    it "should raise an exception if a source is nil when :install" do
+      new_resource.source nil
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect { provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should raise an exception if a source is nil when :upgrade" do
+      new_resource.source nil
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect { provider.run_action(:upgrade) }.to raise_error(Chef::Exceptions::Package)
+    end
+
+    it "should not raise an exception if a source is nil when :remove" do
+      new_resource.source nil
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect(provider).to receive(:action_remove)
+      expect { provider.run_action(:remove) }.not_to raise_error
+    end
+
+    it "should not raise an exception if a source is nil when :purge" do
+      new_resource.source nil
+      allow(::File).to receive(:exist?).with(source).and_return(false)
+      expect(provider).to receive(:action_purge)
+      expect { provider.run_action(:purge) }.not_to raise_error
+    end
   end
 
   describe "when loading the current resource state" do
 
     it "should create a current resource with the name of the new_resource" do
-      @provider.load_current_resource
-      expect(@provider.current_resource.package_name).to eq("wget")
-    end
-
-    it "should raise an exception if a source is supplied but not found" do
-      @provider.load_current_resource
-      @provider.define_resource_requirements
-      allow(::File).to receive(:exists?).and_return(false)
-      expect { @provider.run_action(:install) }.to raise_error(Chef::Exceptions::Package)
+      provider.load_current_resource
+      expect(provider.current_resource.package_name).to eq(["wget"])
     end
 
     describe 'gets the source package version from dpkg-deb' do
       def check_version(version)
-        @status = double(:stdout => "wget\t#{version}", :exitstatus => 0)
-        allow(@provider).to receive(:shell_out).with("dpkg-deb -W #{@new_resource.source}", timeout: 900).and_return(@status)
-        @provider.load_current_resource
-        expect(@provider.current_resource.package_name).to eq("wget")
-        expect(@provider.candidate_version).to eq(version)
+        status = double(:stdout => "wget\t#{version}", :exitstatus => 0)
+        expect(provider).to receive(:shell_out!).with("dpkg-deb -W #{source}", timeout: 900).and_return(status)
+        provider.load_current_resource
+        expect(provider.current_resource.package_name).to eq(["wget"])
+        expect(provider.candidate_version).to eq([version])
       end
 
       it 'if short version provided' do
@@ -74,129 +140,152 @@ describe Chef::Provider::Package::Dpkg do
       end
     end
 
-    it "gets the source package name from dpkg-deb correctly when the package name has `-', `+' or `.' characters" do
-      stdout = "f.o.o-pkg++2\t1.11.4-1ubuntu1"
-      status = double(:stdout => stdout, :exitstatus => 1)
-      allow(@provider).to receive(:shell_out).and_return(status)
-      @provider.load_current_resource
-      expect(@provider.current_resource.package_name).to eq("f.o.o-pkg++2")
+    describe "when the package name has `-', `+' or `.' characters" do
+      let(:package) { "f.o.o-pkg++2" }
+
+      it "gets the source package name from dpkg-deb correctly" do
+        provider.load_current_resource
+        expect(provider.current_resource.package_name).to eq(["f.o.o-pkg++2"])
+      end
     end
 
-    it "gets the source package version from dpkg-deb correctly when the package version has `~', `-', `+' or `.' characters" do
-      stdout = "b.a.r-pkg++1\t1.2.3+3141592-1ubuntu1~lucid"
-      status = double(:stdout => stdout, :exitstatus => 1)
-      allow(@provider).to receive(:shell_out).and_return(status)
-      @provider.load_current_resource
-      expect(@provider.candidate_version).to eq('1.2.3+3141592-1ubuntu1~lucid')
+    describe "when the package version has `~', `-', `+' or `.' characters" do
+      let(:package) { "b.a.r-pkg++1" }
+      let(:dpkg_deb_version) { "1.2.3+3141592-1ubuntu1~lucid" }
+      let(:dpkg_s_version) { "1.2.3+3141592-1ubuntu1~lucid" }
+
+      it "gets the source package version from dpkg-deb correctly when the package version has `~', `-', `+' or `.' characters" do
+        provider.load_current_resource
+        expect(provider.candidate_version).to eq(['1.2.3+3141592-1ubuntu1~lucid'])
+      end
     end
 
-    it "should raise an exception if the source is not set but we are installing" do
-      @new_resource = Chef::Resource::Package.new("wget")
-      @provider.new_resource = @new_resource
-      @provider.load_current_resource
-      @provider.define_resource_requirements
-      expect { @provider.run_action(:install)}.to raise_error(Chef::Exceptions::Package)
+    describe "when the source is not set" do
+      let(:source) { nil }
+
+      it "should raise an exception if the source is not set but we are installing" do
+        expect { provider.run_action(:install)}.to raise_error(Chef::Exceptions::Package)
+      end
     end
 
     it "should return the current version installed if found by dpkg" do
-      stdout = <<-DPKG_S
-Package: wget
-Status: install ok installed
-Priority: important
-Section: web
-Installed-Size: 1944
-Maintainer: Ubuntu Core developers <ubuntu-devel-discuss@lists.ubuntu.com>
-Architecture: amd64
-Version: 1.11.4-1ubuntu1
-Config-Version: 1.11.4-1ubuntu1
-Depends: libc6 (>= 2.8~20080505), libssl0.9.8 (>= 0.9.8f-5)
-Conflicts: wget-ssl
-DPKG_S
-      status = double(:stdout => stdout, :exitstatus => 1)
-      allow(@provider).to receive(:shell_out).with("dpkg -s wget", timeout: 900).and_return(status)
+      allow(provider).to receive(:shell_out!).with("dpkg -s #{package}", timeout: 900, returns: [0,1]).and_return(dpkg_s_status)
+      provider.load_current_resource
+      expect(provider.current_resource.version).to eq(["1.11.4-1ubuntu1"])
+    end
 
-      @provider.load_current_resource
-      expect(@provider.current_resource.version).to eq("1.11.4-1ubuntu1")
+    it "on new debian/ubuntu we get an exit(1) and no stdout from dpkg -s for uninstalled" do
+      dpkg_s_status = double(
+        exitstatus: 1, stdout: "", stderr: <<-EOF
+dpkg-query: package '#{package}' is not installed and no information is available
+Use dpkg --info (= dpkg-deb --info) to examine archive files,
+and dpkg --contents (= dpkg-deb --contents) to list their contents.
+        EOF
+      )
+      expect(provider).to receive(:shell_out!).with("dpkg -s #{package}", returns: [0, 1], timeout: 900).and_return(dpkg_s_status)
+      provider.load_current_resource
+      expect(provider.current_resource.version).to eq([nil])
     end
 
-    it "should raise an exception if dpkg fails to run" do
+    it "on old debian/ubuntu we get an exit(0) and we get info on stdout from dpkg -s for uninstalled" do
+      dpkg_s_status = double(
+        exitstatus: 0, stderr: "", stdout: <<-EOF
+Package: #{package}
+Status: unknown ok not-installed
+Priority: extra
+Section: ruby
+        EOF
+      )
+      expect(provider).to receive(:shell_out!).with("dpkg -s #{package}", returns: [0, 1], timeout: 900).and_return(dpkg_s_status)
+      provider.load_current_resource
+      expect(provider.current_resource.version).to eq([nil])
+    end
+
+    it "and we should raise if we get any other exit codes from dpkg -s" do
+      dpkg_s_status = double(
+        exitstatus: 3, stderr: "i am very, very angry with you.  i'm very, very cross.  go to your room.", stdout: ""
+      )
+      expect(provider).to receive(:shell_out!).with("dpkg -s #{package}", returns: [0, 1], timeout: 900).and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect { provider.load_current_resource }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
+    end
+
+    it "should raise an exception if dpkg-deb -W fails to run" do
       status = double(:stdout => "", :exitstatus => -1)
-      allow(@provider).to receive(:shell_out).and_return(status)
-      expect { @provider.load_current_resource }.to raise_error(Chef::Exceptions::Package)
+      expect(provider).to receive(:shell_out_with_timeout!).with("dpkg-deb -W /tmp/wget_1.11.4-1ubuntu1_amd64.deb").and_raise(Mixlib::ShellOut::ShellCommandFailed)
+      expect { provider.load_current_resource }.to raise_error(Mixlib::ShellOut::ShellCommandFailed)
     end
   end
 
   describe Chef::Provider::Package::Dpkg, "install and upgrade" do
     it "should run dpkg -i with the package source" do
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -i", nil, "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
-      @provider.install_package("wget", "1.11.4-1ubuntu1")
+      provider.load_current_resource
+      provider.run_action(:install)
     end
 
     it "should run dpkg -i if the package is a path and the source is nil" do
-      @new_resource = Chef::Resource::Package.new("/tmp/wget_1.11.4-1ubuntu1_amd64.deb")
-      @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+      new_resource.name "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -i", nil, "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
-      @provider.install_package("/tmp/wget_1.11.4-1ubuntu1_amd64.deb", "1.11.4-1ubuntu1")
+      provider.run_action(:install)
     end
 
     it "should run dpkg -i if the package is a path and the source is nil for an upgrade" do
-      @new_resource = Chef::Resource::Package.new("/tmp/wget_1.11.4-1ubuntu1_amd64.deb")
-      @provider = Chef::Provider::Package::Dpkg.new(@new_resource, @run_context)
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -i /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+      new_resource.name "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -i", nil, "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
-      @provider.upgrade_package("/tmp/wget_1.11.4-1ubuntu1_amd64.deb", "1.11.4-1ubuntu1")
+      provider.run_action(:upgrade)
     end
 
     it "should run dpkg -i with the package source and options if specified" do
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -i --force-yes /tmp/wget_1.11.4-1ubuntu1_amd64.deb"
+      new_resource.options "--force-yes"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -i", "--force-yes", "/tmp/wget_1.11.4-1ubuntu1_amd64.deb"
       )
-      allow(@new_resource).to receive(:options).and_return("--force-yes")
-
-      @provider.install_package("wget", "1.11.4-1ubuntu1")
+      provider.run_action(:install)
     end
+
     it "should upgrade by running install_package" do
-      expect(@provider).to receive(:install_package).with("wget", "1.11.4-1ubuntu1")
-      @provider.upgrade_package("wget", "1.11.4-1ubuntu1")
+      expect(provider).to receive(:install_package).with(["wget"], ["1.11.4-1ubuntu1"])
+      provider.upgrade_package(["wget"], ["1.11.4-1ubuntu1"])
     end
   end
 
   describe Chef::Provider::Package::Dpkg, "remove and purge" do
     it "should run dpkg -r to remove the package" do
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -r wget"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -r", nil, "wget"
       )
-      @provider.remove_package("wget", "1.11.4-1ubuntu1")
+      provider.remove_package(["wget"], ["1.11.4-1ubuntu1"])
     end
 
     it "should run dpkg -r to remove the package with options if specified" do
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -r --force-yes wget"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -r", "--force-yes", "wget"
       )
-      allow(@new_resource).to receive(:options).and_return("--force-yes")
+      allow(new_resource).to receive(:options).and_return("--force-yes")
 
-      @provider.remove_package("wget", "1.11.4-1ubuntu1")
+      provider.remove_package(["wget"], ["1.11.4-1ubuntu1"])
     end
 
     it "should run dpkg -P to purge the package" do
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -P wget"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -P", nil, "wget"
       )
-      @provider.purge_package("wget", "1.11.4-1ubuntu1")
+      provider.purge_package(["wget"], ["1.11.4-1ubuntu1"])
     end
 
     it "should run dpkg -P to purge the package with options if specified" do
-      expect(@provider).to receive(:run_noninteractive).with(
-        "dpkg -P --force-yes wget"
+      expect(provider).to receive(:run_noninteractive).with(
+        "dpkg -P", "--force-yes", "wget"
       )
-      allow(@new_resource).to receive(:options).and_return("--force-yes")
+      allow(new_resource).to receive(:options).and_return("--force-yes")
 
-      @provider.purge_package("wget", "1.11.4-1ubuntu1")
+      provider.purge_package(["wget"], ["1.11.4-1ubuntu1"])
     end
   end
 end