puppet 3.2.4 → 3.3.0.rc2

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

@@ -2,105 +2,93 @@
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
-provider_class = Puppet::Type.type(:mount).provider(:parsed)
+describe Puppet::Type.type(:mount).provider(:parsed), :unless => Puppet.features.microsoft_windows? do
 
-describe provider_class, :unless => Puppet.features.microsoft_windows? do
+  let :vfstab_sample do
+    "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
+  end
 
-  before :each do
-    @mount_class = Puppet::Type.type(:mount)
-    @provider = @mount_class.provider(:parsed)
+  let :fstab_sample do
+    "/dev/vg00/lv01\t/spare   \t  \t   ext3    defaults\t1 2"
   end
 
   # LAK:FIXME I can't mock Facter because this test happens at parse-time.
   it "should default to /etc/vfstab on Solaris" do
     pending "This test only works on Solaris" unless Facter.value(:osfamily) == 'Solaris'
-    Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/vfstab'
+    described_class.default_target.should == '/etc/vfstab'
   end
 
   it "should default to /etc/fstab on anything else" do
     pending "This test does not work on Solaris" if Facter.value(:osfamily) == 'Solaris'
-    Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/fstab'
+    described_class.default_target.should == '/etc/fstab'
   end
 
   describe "when parsing a line" do
-
     it "should not crash on incomplete lines in fstab" do
-      parse = @provider.parse <<-FSTAB
+      parse = described_class.parse <<-FSTAB
 /dev/incomplete
 /dev/device       name
 FSTAB
-      lambda{ @provider.to_line(parse[0]) }.should_not raise_error
+      expect { described_class.to_line(parse[0]) }.to_not raise_error
     end
 
 #   it_should_behave_like "all parsedfile providers",
 #     provider_class, my_fixtures('*.fstab')
 
     describe "on Solaris", :if => Facter.value(:osfamily) == 'Solaris' do
-
-      before :each do
-        @example_line = "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
-      end
-
       it "should extract device from the first field" do
-        @provider.parse_line(@example_line)[:device].should == '/dev/dsk/c0d0s0'
+        described_class.parse_line(vfstab_sample)[:device].should == '/dev/dsk/c0d0s0'
       end
 
       it "should extract blockdevice from second field" do
-        @provider.parse_line(@example_line)[:blockdevice].should == "/dev/rdsk/c0d0s0"
+        described_class.parse_line(vfstab_sample)[:blockdevice].should == "/dev/rdsk/c0d0s0"
       end
 
       it "should extract name from third field" do
-        @provider.parse_line(@example_line)[:name].should == "/"
+        described_class.parse_line(vfstab_sample)[:name].should == "/"
       end
 
       it "should extract fstype from fourth field" do
-        @provider.parse_line(@example_line)[:fstype].should == "ufs"
+        described_class.parse_line(vfstab_sample)[:fstype].should == "ufs"
       end
 
       it "should extract pass from fifth field" do
-        @provider.parse_line(@example_line)[:pass].should == "1"
+        described_class.parse_line(vfstab_sample)[:pass].should == "1"
       end
 
       it "should extract atboot from sixth field" do
-        @provider.parse_line(@example_line)[:atboot].should == "no"
+        described_class.parse_line(vfstab_sample)[:atboot].should == "no"
       end
 
       it "should extract options from seventh field" do
-        @provider.parse_line(@example_line)[:options].should == "-"
+        described_class.parse_line(vfstab_sample)[:options].should == "-"
       end
-
     end
 
     describe "on other platforms than Solaris", :if => Facter.value(:osfamily) != 'Solaris' do
-
-      before :each do
-        @example_line = "/dev/vg00/lv01\t/spare   \t  \t   ext3    defaults\t1 2"
-      end
-
       it "should extract device from the first field" do
-        @provider.parse_line(@example_line)[:device].should == '/dev/vg00/lv01'
+        described_class.parse_line(fstab_sample)[:device].should == '/dev/vg00/lv01'
       end
 
       it "should extract name from second field" do
-        @provider.parse_line(@example_line)[:name].should == "/spare"
+        described_class.parse_line(fstab_sample)[:name].should == "/spare"
       end
 
       it "should extract fstype from third field" do
-        @provider.parse_line(@example_line)[:fstype].should == "ext3"
+        described_class.parse_line(fstab_sample)[:fstype].should == "ext3"
       end
 
       it "should extract options from fourth field" do
-        @provider.parse_line(@example_line)[:options].should == "defaults"
+        described_class.parse_line(fstab_sample)[:options].should == "defaults"
       end
 
       it "should extract dump from fifth field" do
-        @provider.parse_line(@example_line)[:dump].should == "1"
+        described_class.parse_line(fstab_sample)[:dump].should == "1"
       end
 
       it "should extract options from sixth field" do
-        @provider.parse_line(@example_line)[:pass].should == "2"
+        described_class.parse_line(fstab_sample)[:pass].should == "2"
       end
-
     end
 
   end
@@ -108,8 +96,8 @@ FSTAB
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
       Facter.stubs(:value).with(:osfamily).returns 'Solaris'
-      @provider.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
-      mounts = @provider.mountinstances
+      described_class.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
+      mounts = described_class.mountinstances
       mounts.size.should == 6
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/proc', :mounted => :yes }
@@ -121,8 +109,8 @@ FSTAB
 
     it "should get name from mountoutput found on HP-UX" do
       Facter.stubs(:value).with(:osfamily).returns 'HP-UX'
-      @provider.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
-      mounts = @provider.mountinstances
+      described_class.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
+      mounts = described_class.mountinstances
       mounts.size.should == 17
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/devices', :mounted => :yes }
@@ -145,8 +133,8 @@ FSTAB
 
     it "should get name from mountoutput found on Darwin" do
       Facter.stubs(:value).with(:osfamily).returns 'Darwin'
-      @provider.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
-      mounts = @provider.mountinstances
+      described_class.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
+      mounts = described_class.mountinstances
       mounts.size.should == 6
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/dev', :mounted => :yes }
@@ -158,8 +146,8 @@ FSTAB
 
     it "should get name from mountoutput found on Linux" do
       Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
-      @provider.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
-      mounts = @provider.mountinstances
+      described_class.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
+      mounts = described_class.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/lib64/rc/init.d', :mounted => :yes }
       mounts[2].should == { :name => '/sys', :mounted => :yes }
@@ -169,8 +157,8 @@ FSTAB
 
     it "should get name from mountoutput found on AIX" do
       Facter.stubs(:value).with(:osfamily).returns 'AIX'
-      @provider.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
-      mounts = @provider.mountinstances
+      described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
+      mounts = described_class.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/tmp', :mounted => :yes }
       mounts[2].should == { :name => '/home', :mounted => :yes }
@@ -179,8 +167,8 @@ FSTAB
     end
 
     it "should raise an error if a line is not understandable" do
-      @provider.stubs(:mountcmd).returns("bazinga!")
-      lambda { @provider.mountinstances }.should raise_error Puppet::Error
+      described_class.stubs(:mountcmd).returns("bazinga!")
+      expect { described_class.mountinstances }.to raise_error Puppet::Error, 'Could not understand line bazinga! from mount output'
     end
 
   end
@@ -203,7 +191,7 @@ FSTAB
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
-          @provider.stubs(:mountcmd).returns File.read(mount)
+          described_class.stubs(:mountcmd).returns File.read(mount)
         rescue
           pending "is #{platform}.mount missing at this point?"
         end
@@ -211,8 +199,8 @@ FSTAB
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
-        @provider.stubs(:default_target).returns fstab
-        @retrieve = @provider.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
+        described_class.stubs(:default_target).returns fstab
+        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
       # Following mountpoint are present in all fstabs/mountoutputs
@@ -246,7 +234,7 @@ FSTAB
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
-          @provider.stubs(:mountcmd).returns File.read(mount)
+          described_class.stubs(:mountcmd).returns File.read(mount)
         rescue
           pending "is #{platform}.mount missing at this point?"
         end
@@ -254,7 +242,7 @@ FSTAB
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
-        @provider.stubs(:default_target).returns fstab
+        described_class.stubs(:default_target).returns fstab
 
         @res_ghost = Puppet::Type::Mount.new(:name => '/ghost')    # in no fake fstab
         @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab
@@ -270,24 +258,24 @@ FSTAB
 
       it "should set :ensure to :unmounted if found in fstab but not mounted" do
         pending("Solaris:Unable to stub Operating System Fact at runtime", :if => Facter.value(:osfamily) == "Solaris")
-        @provider.prefetch(@resource_hash)
+        described_class.prefetch(@resource_hash)
         @res_unmounted.provider.get(:ensure).should == :unmounted
       end
 
       it "should set :ensure to :ghost if not found in fstab but mounted" do
         pending("Solaris:Unable to stub Operating System Fact at runtime", :if => Facter.value(:osfamily) == "Solaris")
-        @provider.prefetch(@resource_hash)
+        described_class.prefetch(@resource_hash)
         @res_ghost.provider.get(:ensure).should == :ghost
       end
 
       it "should set :ensure to :mounted if found in fstab and mounted" do
         pending("Solaris:Unable to stub Operating System Fact at runtime", :if => Facter.value(:osfamily) == "Solaris")
-        @provider.prefetch(@resource_hash)
+        described_class.prefetch(@resource_hash)
         @res_mounted.provider.get(:ensure).should == :mounted
       end
 
       it "should set :ensure to :absent if not found in fstab and not mounted" do
-        @provider.prefetch(@resource_hash)
+        described_class.prefetch(@resource_hash)
         @res_absent.provider.get(:ensure).should == :absent
       end
     end

data/spec/unit/provider/mount_spec.rb

@@ -29,9 +29,18 @@ describe Puppet::Provider::Mount do
       @mounter.mount
     end
 
-    it "should add the options following '-o' if they exist and are not set to :absent" do
+    it "should add the options following '-o' on MacOS if they exist and are not set to :absent" do
+      Facter.expects(:value).with(:kernel).returns 'Darwin'
       @mounter.stubs(:options).returns("ro")
-      @mounter.expects(:mountcmd).with { |*ary| ary[0] == "-o" and ary[1] == "ro" }
+      @mounter.expects(:mountcmd).with '-o', 'ro', '/'
+
+      @mounter.mount
+    end
+
+    it "should not explicitly pass mount options on systems other than MacOS" do
+      Facter.expects(:value).with(:kernel).returns 'HP-UX'
+      @mounter.stubs(:options).returns("ro")
+      @mounter.expects(:mountcmd).with '/'
 
       @mounter.mount
     end

data/spec/unit/provider/naginator_spec.rb

@@ -55,3 +55,11 @@ describe Puppet::Provider::Naginator do
     @class.should_not be_skip_record("foo")
   end
 end
+
+describe Nagios::Base do
+  it "should not turn set parameters into arrays #17871" do
+    obj = Nagios::Base.create('host')
+    obj.host_name = "my_hostname"
+    obj.host_name.should == "my_hostname"
+  end
+end

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

@@ -8,7 +8,11 @@ describe provider do
     @resource = stub 'resource', :[] => "asdf"
     @provider = provider.new(@resource)
 
-    @fakeresult = "install ok installed asdf 1.0\n"
+    @fakeresult = <<-EOF
+install ok installed asdf 1.0 "asdf summary
+ asdf multiline description
+ with multiple lines
+EOF
   end
 
   it "should be versionable" do

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

@@ -10,13 +10,17 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
   it { should be_versionable }
 
   context "when retrieving ensure" do
-    { :absent   => "deinstall ok config-files faff 1.2.3-1\n",
-      "1.2.3-1" => "install ok installed faff 1.2.3-1\n",
+    before do
+      described_class.stubs(:command).with(:dpkgquery).returns 'myquery'
+    end
+
+    { :absent   => "deinstall ok config-files faff 1.2.3-1 :DESC: faff summary\n:DESC:\n",
+      "1.2.3-1" => "install ok installed faff 1.2.3-1 :DESC: faff summary\n:DESC:\n",
     }.each do |expect, output|
       it "should detect #{expect} packages" do
-        pkg.provider.expects(:dpkgquery).
-          with('-W', '--showformat', '${Status} ${Package} ${Version}\n', 'faff').
-          returns(output)
+        Puppet::Util::Execution.expects(:execpipe).
+          with(['myquery', '-W', '--showformat', "'${Status} ${Package} ${Version} :DESC: ${Description}\\n:DESC:\\n'", 'faff']).
+          yields(StringIO.new(output))
 
         pkg.property(:ensure).retrieve.should == expect
       end

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

@@ -19,7 +19,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
     def rpm
       pkg.provider.expects(:rpm).
         with('-q', 'faff', '--nosignature', '--nodigest', '--qf',
-             "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n")
+             "'%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH} :DESC: %{SUMMARY}\\n'")
     end
 
     it "should report absent packages" do
@@ -28,7 +28,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
     end
 
     it "should report present packages correctly" do
-      rpm.returns("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
+      rpm.returns("faff-1.2.3-1 0 1.2.3-1 5 i686 :DESC: faff desc\n")
       pkg.property(:ensure).retrieve.should == "1.2.3-1-5"
     end
   end

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

@@ -2,226 +2,401 @@
 require 'spec_helper'
 require 'stringio'
 
-provider = Puppet::Type.type(:package).provider(:dpkg)
+provider_class = Puppet::Type.type(:package).provider(:dpkg)
+
+describe provider_class do
+  let(:bash_version) { '4.2-5ubuntu3' }
+  let(:bash_installed_output) do <<-EOS
+install ok installed bash #{bash_version} :DESC: GNU Bourne Again SHell
+ Bash is an sh-compatible command language interpreter that executes
+ commands read from the standard input or from a file.  Bash also
+ incorporates useful features from the Korn and C shells (ksh and csh).
+ .
+ Bash is ultimately intended to be a conformant implementation of the
+ IEEE POSIX Shell and Tools specification (IEEE Working Group 1003.2).
+ .
+ The Programmable Completion Code, by Ian Macdonald, is now found in
+ the bash-completion package.
+:DESC:
+    EOS
+  end
+  let(:bash_installed_io) { StringIO.new(bash_installed_output) }
+
+  let(:vim_installed_output) do <<-EOS
+install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi editor
+ Vim is an almost compatible version of the UNIX editor Vi.
+ .
+ Many new features have been added: multi level undo, syntax
+ highlighting, command line history, on-line help, filename
+ completion, block operations, folding, Unicode support, etc.
+ .
+ This package contains a version of vim compiled with a rather
+ standard set of features.  This package does not provide a GUI
+ version of Vim.  See the other vim-* packages if you need more
+ (or less).
+:DESC:
+    EOS
+  end
 
-describe provider do
-  before do
-    @resource = stub 'resource', :[] => "asdf"
-    @provider = provider.new(@resource)
-    @provider.expects(:execute).never # forbid "manual" executions
+  let(:all_installed_io) { StringIO.new([bash_installed_output, vim_installed_output].join) }
+  let(:args) { ['myquery', '-W', '--showformat', %Q{'${Status} ${Package} ${Version} :DESC: ${Description}\\n:DESC:\\n'}] }
+  let(:resource_name) { 'package' }
+  let(:resource) { stub 'resource', :[] => resource_name }
+  let(:provider) { provider_class.new(resource) }
 
-    @fakeresult = "install ok installed asdf 1.0\n"
+  before do
+    provider_class.stubs(:command).with(:dpkgquery).returns 'myquery'
   end
 
   it "should have documentation" do
-    provider.doc.should be_instance_of(String)
+    provider_class.doc.should be_instance_of(String)
   end
 
   describe "when listing all instances" do
-    before do
-      provider.stubs(:command).with(:dpkgquery).returns "myquery"
-    end
 
     it "should use dpkg-query" do
-      provider.expects(:command).with(:dpkgquery).returns "myquery"
-      Puppet::Util::Execution.expects(:execpipe).with("myquery -W --showformat '${Status} ${Package} ${Version}\\n'").yields StringIO.new(@fakeresult)
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields bash_installed_io
 
-      provider.instances
+      provider_class.instances
     end
 
-    it "should create and return an instance with each parsed line from dpkg-query" do
-      pipe = mock 'pipe'
-      pipe.expects(:each).never
-      pipe.expects(:each_line).yields @fakeresult
-      Puppet::Util::Execution.expects(:execpipe).yields pipe
+    it "should create and return an instance for a single dpkg-query entry" do
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields bash_installed_io
 
-      asdf = mock 'pkg1'
-      provider.expects(:new).with(:ensure => "1.0", :error => "ok", :desired => "install", :name => "asdf", :status => "installed", :provider => :dpkg).returns asdf
+      installed = mock 'bash'
+      provider_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :description => "GNU Bourne Again SHell", :provider => :dpkg).returns installed
 
-      provider.instances.should == [asdf]
+      provider_class.instances.should == [installed]
+    end
+
+    it "should parse multiple dpkg-query multi-line entries in the output" do
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields all_installed_io
+
+      bash = mock 'bash'
+      provider_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :description => "GNU Bourne Again SHell", :provider => :dpkg).returns bash
+      vim = mock 'vim'
+      provider_class.expects(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :description => "Vi IMproved - enhanced vi editor", :provider => :dpkg).returns vim
+
+      provider_class.instances.should == [bash, vim]
     end
 
     it "should warn on and ignore any lines it does not understand" do
-      pipe = mock 'pipe'
-      pipe.expects(:each).never
-      pipe.expects(:each_line).yields "foobar"
-      Puppet::Util::Execution.expects(:execpipe).yields pipe
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields StringIO.new('foobar')
 
       Puppet.expects(:warning)
-      provider.expects(:new).never
+      provider_class.expects(:new).never
+
+      provider_class.instances.should == []
+    end
+
+    it "should not warn on extra multiline description lines which we are ignoring" do
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields all_installed_io
 
-      provider.instances.should == []
+      Puppet.expects(:warning).never
+      provider_class.instances
+    end
+
+    it "should warn if encounters bad lines between good entries without failing" do
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join)
+
+      Puppet.expects(:warning)
+
+      bash = mock 'bash'
+      vim = mock 'vim'
+      provider_class.expects(:new).twice.returns(bash, vim)
+
+      provider_class.instances.should == [bash, vim]
+    end
+
+    it "should warn on a broken entry while still parsing a good one" do
+      Puppet::Util::Execution.expects(:execpipe).with(args).yields StringIO.new([
+        bash_installed_output,
+        %Q{install ok installed broken 1.0 this shouldn't be here :DESC: broken description\n extra description\n:DESC:\n},
+        vim_installed_output,
+      ].join)
+
+      Puppet.expects(:warning).times(3)
+
+      bash = mock('bash')
+      vim = mock('vim')
+      saved = mock('saved')
+      provider_class.expects(:new).twice.returns(bash, vim)
+
+      provider_class.instances.should == [bash, vim]
     end
   end
 
   describe "when querying the current state" do
-    it "should use dpkg-query" do
-      @provider.expects(:dpkgquery).with("-W", "--showformat",'${Status} ${Package} ${Version}\\n', "asdf").returns @fakeresult
+    let(:query_args) { args.push(resource_name) }
 
-      @provider.query
+    before do
+      provider.expects(:execute).never # forbid "manual" executions
+    end
+
+    # @return [StringIO] of bash dpkg-query output with :search string replaced
+    # by :replace string.
+    def replace_in_bash_output(search, replace)
+      StringIO.new(bash_installed_output.gsub(search, replace))
+    end
+
+    it "should use exec-pipe" do
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields bash_installed_io
+
+      provider.query
     end
 
     it "should consider the package purged if dpkg-query fails" do
-      @provider.expects(:dpkgquery).raises Puppet::ExecutionFailure.new("eh")
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).raises Puppet::ExecutionFailure.new("eh")
 
-      @provider.query[:ensure].should == :purged
+      provider.query[:ensure].should == :purged
     end
 
-    it "should return a hash of the found status with the desired state, error state, status, name, and 'ensure'" do
-      @provider.expects(:dpkgquery).returns @fakeresult
+    it "should return a hash of the found package status for an installed package" do
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields bash_installed_io
 
-      @provider.query.should == {:ensure => "1.0", :error => "ok", :desired => "install", :name => "asdf", :status => "installed", :provider => :dpkg}
+      provider.query.should == {:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg, :description => "GNU Bourne Again SHell"}
     end
 
     it "should consider the package absent if the dpkg-query result cannot be interpreted" do
-      @provider.expects(:dpkgquery).returns "somebaddata"
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields StringIO.new("somebaddata")
 
-      @provider.query[:ensure].should == :absent
+      provider.query[:ensure].should == :absent
     end
 
     it "should fail if an error is discovered" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("ok", "error")
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("ok", "error")
 
-      lambda { @provider.query }.should raise_error(Puppet::Error)
+      lambda { provider.query }.should raise_error(Puppet::Error)
     end
 
     it "should consider the package purged if it is marked 'not-installed'" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "not-installed")
+      not_installed_bash = bash_installed_output.gsub("installed", "not-installed")
+      not_installed_bash.gsub!(bash_version, "")
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields StringIO.new(not_installed_bash)
 
-      @provider.query[:ensure].should == :purged
+      provider.query[:ensure].should == :purged
     end
 
     it "should consider the package absent if it is marked 'config-files'" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "config-files")
-      @provider.query[:ensure].should == :absent
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "config-files")
+      provider.query[:ensure].should == :absent
     end
 
     it "should consider the package absent if it is marked 'half-installed'" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "half-installed")
-      @provider.query[:ensure].should == :absent
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "half-installed")
+      provider.query[:ensure].should == :absent
     end
 
     it "should consider the package absent if it is marked 'unpacked'" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "unpacked")
-      @provider.query[:ensure].should == :absent
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "unpacked")
+      provider.query[:ensure].should == :absent
     end
 
     it "should consider the package absent if it is marked 'half-configured'" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "half-configured")
-      @provider.query[:ensure].should == :absent
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "half-configured")
+      provider.query[:ensure].should == :absent
     end
 
     it "should consider the package held if its state is 'hold'" do
-      @provider.expects(:dpkgquery).returns @fakeresult.sub("install", "hold")
-      @provider.query[:ensure].should == :held
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("install", "hold")
+      provider.query[:ensure].should == :held
+    end
+  end
+
+  describe "parsing tests" do
+    let(:resource_name) { 'name' }
+    let(:package_hash) do
+      {
+        :desired => 'desired',
+        :error => 'ok',
+        :status => 'status',
+        :name => resource_name,
+        :ensure => 'ensure',
+        :description => 'summary text',
+        :provider => :dpkg,
+      }
+    end
+    let(:query_args) { args.push(resource_name) }
+
+    it "warns about excess lines if encounters a delimiter in description but does not fail" do
+      broken_description = <<-EOS
+desired ok status name ensure :DESC: summary text
+ more description
+:DESC:
+ 1 whoops ^^ should not happen, because dpkg-query is supposed to prefix description lines with
+ 2 whitespace.  So we should see three warnings for these four additional lines when we try
+ 3 and process next-pkg (vv the :DESC: is line number 4)
+:DESC:
+desired ok status next-pkg ensure :DESC: next summary
+:DESC:
+      EOS
+      Puppet.expects(:warning).times(4)
+
+      pipe = StringIO.new(broken_description)
+      provider_class.parse_multi_line(pipe).should == package_hash
+
+      next_package = package_hash.merge(:name => 'next-pkg', :description => 'next summary')
+
+      hash = provider_class.parse_multi_line(pipe) until hash # warn about bad lines
+      hash.should == next_package
+    end
+
+    def parser_test(dpkg_output_string, gold_hash)
+      pipe = StringIO.new(dpkg_output_string)
+      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields pipe
+      Puppet.expects(:warning).never
+
+      provider.query.should == gold_hash
+    end
+
+    it "should parse properly even if delimiter is in version" do
+      version_delimiter = <<-EOS
+desired ok status name 1.2.3-:DESC: :DESC: summary text
+ more description
+:DESC:
+      EOS
+      parser_test(version_delimiter, package_hash.merge(:ensure => '1.2.3-:DESC:'))
+    end
+
+    it "should parse properly even if delimiter is name" do
+      name_delimiter = <<-EOS
+desired ok status :DESC: ensure :DESC: summary text
+ more description
+:DESC:
+      EOS
+      parser_test(name_delimiter, package_hash.merge(:name => ':DESC:'))
+    end
+
+    it "should parse properly even if optional ensure field is missing" do
+      no_ensure = <<-EOS
+desired ok status name  :DESC: summary text
+ more description and note^ two spaces surround the hole where 'ensure' field would be...
+:DESC:
+      EOS
+      parser_test(no_ensure, package_hash.merge(:ensure => ''))
+    end
+
+    it "should parse properly even if extra delimiter is in summary" do
+      extra_description_delimiter = <<-EOS
+desired ok status name ensure :DESC: summary text
+ :DESC: should be completely ignored because of leading space which dpkg-query should ensure
+:DESC:
+      EOS
+      parser_test(extra_description_delimiter, package_hash)
+    end
+
+    it "should parse properly even if package description is completely missing" do
+      no_description = "desired ok status name ensure :DESC: \n:DESC:"
+      parser_test(no_description, package_hash.merge(:description => ''))
     end
   end
 
   it "should be able to install" do
-    @provider.should respond_to(:install)
+    provider.should respond_to(:install)
   end
 
   describe "when installing" do
     before do
-      @resource.stubs(:[]).with(:source).returns "mypkg"
+      resource.stubs(:[]).with(:source).returns "mypkg"
     end
 
     it "should fail to install if no source is specified in the resource" do
-      @resource.expects(:[]).with(:source).returns nil
+      resource.expects(:[]).with(:source).returns nil
 
-      lambda { @provider.install }.should raise_error(ArgumentError)
+      lambda { provider.install }.should raise_error(ArgumentError)
     end
 
     it "should use 'dpkg -i' to install the package" do
-      @resource.expects(:[]).with(:source).returns "mypackagefile"
-      @provider.expects(:unhold)
-      @provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
+      resource.expects(:[]).with(:source).returns "mypackagefile"
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
 
-      @provider.install
+      provider.install
     end
 
     it "should keep old config files if told to do so" do
-      @resource.expects(:[]).with(:configfiles).returns :keep
-      @provider.expects(:unhold)
-      @provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
+      resource.expects(:[]).with(:configfiles).returns :keep
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
 
-      @provider.install
+      provider.install
     end
 
     it "should replace old config files if told to do so" do
-      @resource.expects(:[]).with(:configfiles).returns :replace
-      @provider.expects(:unhold)
-      @provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
+      resource.expects(:[]).with(:configfiles).returns :replace
+      provider.expects(:unhold)
+      provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
 
-      @provider.install
+      provider.install
     end
 
     it "should ensure any hold is removed" do
-      @provider.expects(:unhold).once
-      @provider.expects(:dpkg)
-      @provider.install
+      provider.expects(:unhold).once
+      provider.expects(:dpkg)
+      provider.install
     end
   end
 
   describe "when holding or unholding" do
+    let(:tempfile) { stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file" }
+
     before do
-      @tempfile = stub 'tempfile', :print => nil, :close => nil, :flush => nil, :path => "/other/file"
-      @tempfile.stubs(:write)
-      Tempfile.stubs(:new).returns @tempfile
+      tempfile.stubs(:write)
+      Tempfile.stubs(:new).returns tempfile
     end
 
     it "should install first if holding" do
-      @provider.stubs(:execute)
-      @provider.expects(:install).once
-      @provider.hold
+      provider.stubs(:execute)
+      provider.expects(:install).once
+      provider.hold
     end
 
     it "should execute dpkg --set-selections when holding" do
-      @provider.stubs(:install)
-      @provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => @tempfile.path}).once
-      @provider.hold
+      provider.stubs(:install)
+      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
+      provider.hold
     end
 
     it "should execute dpkg --set-selections when unholding" do
-      @provider.stubs(:install)
-      @provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => @tempfile.path}).once
-      @provider.hold
+      provider.stubs(:install)
+      provider.expects(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
+      provider.hold
     end
   end
 
   it "should use :install to update" do
-    @provider.expects(:install)
-    @provider.update
+    provider.expects(:install)
+    provider.update
   end
 
   describe "when determining latest available version" do
     it "should return the version found by dpkg-deb" do
-      @resource.expects(:[]).with(:source).returns "myfile"
-      @provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "asdf\t1.0"
-      @provider.latest.should == "1.0"
+      resource.expects(:[]).with(:source).returns "myfile"
+      provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "package\t1.0"
+      provider.latest.should == "1.0"
     end
 
     it "should warn if the package file contains a different package" do
-      @provider.expects(:dpkg_deb).returns("foo\tversion")
-      @provider.expects(:warning)
-      @provider.latest
+      provider.expects(:dpkg_deb).returns("foo\tversion")
+      provider.expects(:warning)
+      provider.latest
     end
 
     it "should cope with names containing ++" do
-      @resource = stub 'resource', :[] => "asdf++"
-      @provider = provider.new(@resource)
-      @provider.expects(:dpkg_deb).returns "asdf++\t1.0"
-      @provider.latest.should == "1.0"
+      resource = stub 'resource', :[] => "package++"
+      provider = provider_class.new(resource)
+      provider.expects(:dpkg_deb).returns "package++\t1.0"
+      provider.latest.should == "1.0"
     end
   end
 
   it "should use 'dpkg -r' to uninstall" do
-    @provider.expects(:dpkg).with("-r", "asdf")
-    @provider.uninstall
+    provider.expects(:dpkg).with("-r", resource_name)
+    provider.uninstall
   end
 
   it "should use 'dpkg --purge' to purge" do
-    @provider.expects(:dpkg).with("--purge", "asdf")
-    @provider.purge
+    provider.expects(:dpkg).with("--purge", resource_name)
+    provider.purge
   end
 end