puppet 3.4.2 → 3.4.3

data/spec/unit/node/environment_spec.rb

@@ -51,7 +51,6 @@ describe Puppet::Node::Environment do
       before do
         @collection = Puppet::Resource::TypeCollection.new(env)
         env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
-        $known_resource_types = nil
       end
 
       it "should create a resource type collection if none exists" do
@@ -75,18 +74,13 @@ describe Puppet::Node::Environment do
         env.known_resource_types.should equal(@collection)
       end
 
-      it "should return the current thread associated collection if there is one" do
-        $known_resource_types = @collection
-
-        env.known_resource_types.should equal(@collection)
-      end
-
       it "should generate a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
         old_type_collection.stubs(:require_reparse?).returns true
-        $known_resource_types = nil
-        new_type_collection = env.known_resource_types
 
+        env.check_for_reparse
+
+        new_type_collection = env.known_resource_types
         new_type_collection.should be_a Puppet::Resource::TypeCollection
         new_type_collection.should_not equal(old_type_collection)
       end
@@ -416,10 +410,9 @@ describe Puppet::Node::Environment do
 
       it "should fail helpfully if there is an error importing" do
         Puppet::FileSystem::File.stubs(:exist?).returns true
-        env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
         @parser.expects(:file=).once
         @parser.expects(:parse).raises ArgumentError
-        lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error)
+        lambda { env.known_resource_types }.should raise_error(Puppet::Error)
       end
 
       it "should not do anything if the ignore_import settings is set" do
@@ -432,9 +425,8 @@ describe Puppet::Node::Environment do
 
       it "should mark the type collection as needing a reparse when there is an error parsing" do
         @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
-        env.stubs(:known_resource_types).returns Puppet::Resource::TypeCollection.new(env)
 
-        lambda { env.instance_eval { perform_initial_import } }.should raise_error(Puppet::Error, /Syntax error at .../)
+        lambda { env.known_resource_types }.should raise_error(Puppet::Error, /Syntax error at .../)
         env.known_resource_types.require_reparse?.should be_true
       end
     end

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

@@ -10,24 +10,27 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
   it { should be_versionable }
 
   context "when retrieving ensure" do
+    let(:dpkgquery_path) { '/bin/dpkg-query' }
+
     before do
-      described_class.stubs(:command).with(:dpkgquery).returns 'myquery'
+      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
     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",
+    { :absent   => "deinstall ok config-files faff 1.2.3-1\n",
+      "1.2.3-1" => "install ok installed faff 1.2.3-1\n",
     }.each do |expect, output|
-      it "should detect #{expect} packages" do
-        Puppet::Util::Execution.expects(:execpipe).
-          with(['myquery', '-W', '--showformat', "'${Status} ${Package} ${Version} :DESC: ${Description}\\n:DESC:\\n'", 'faff']).
-          yields(StringIO.new(output))
+      it "detects #{expect} packages" do
+        Puppet::Util::Execution.expects(:execute).with(
+          [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
+          {:failonfail => true, :combine => true, :custom_environment => {}}
+        ).returns(output)
 
-        pkg.property(:ensure).retrieve.should == expect
+        expect(pkg.property(:ensure).retrieve).to eq(expect)
       end
     end
   end
 
-  it "should try and install when asked" do
+  it "installs when asked" do
     pkg.provider.expects(:aptitude).
       with('-y', '-o', 'DPkg::Options::=--force-confold', :install, 'faff').
       returns(0)
@@ -35,7 +38,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
     pkg.provider.install
   end
 
-  it "should try and purge when asked" do
+  it "purges when asked" do
     pkg.provider.expects(:aptitude).with('-y', 'purge', 'faff').returns(0)
     pkg.provider.purge
   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} :DESC: %{SUMMARY}\\n")
+             "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\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 :DESC: faff desc\n")
+      rpm.returns("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
       pkg.property(:ensure).retrieve.should == "1.2.3-1-5"
     end
   end

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

@@ -6,100 +6,51 @@ 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_output) { "install ok installed bash #{bash_version}\n" }
   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
-
+  let(:vim_installed_output) { "install ok installed vim 2:7.3.547-6ubuntu5\n" }
   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(:args) { ['-W', '--showformat', %Q{'${Status} ${Package} ${Version}\\n'}] }
+  let(:execute_options) do
+    {:failonfail => true, :combine => true, :custom_environment => {}}
+  end
   let(:resource_name) { 'package' }
   let(:resource) { stub 'resource', :[] => resource_name }
   let(:provider) { provider_class.new(resource) }
 
-  before do
-    provider_class.stubs(:command).with(:dpkgquery).returns 'myquery'
-  end
-
-  it "should have documentation" do
+  it "has documentation" do
     expect(provider_class.doc).to be_instance_of(String)
   end
 
   describe "when listing all instances" do
+    let(:execpipe_args) { args.unshift('myquery') }
 
-    it "should use dpkg-query" do
-      Puppet::Util::Execution.expects(:execpipe).with(args).yields bash_installed_io
-
-      provider_class.instances
+    before do
+      provider_class.stubs(:command).with(:dpkgquery).returns 'myquery'
     end
 
-    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
+    it "creates and return an instance for a single dpkg-query entry" do
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields bash_installed_io
 
       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_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).returns installed
 
       expect(provider_class.instances).to eq([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
+    it "parses multiple dpkg-query multi-line entries in the output" do
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_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
+      provider_class.expects(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :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.expects(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).returns vim
 
       expect(provider_class.instances).to eq([bash, vim])
     end
 
-    it "should warn on and ignore any lines it does not understand" do
-      Puppet::Util::Execution.expects(:execpipe).with(args).yields StringIO.new('foobar')
-
-      Puppet.expects(:warning)
-      provider_class.expects(:new).never
-
-      expect(provider_class.instances).to eq([])
-    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
-
-      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)
+    it "continues without failing if it encounters bad lines between good entries" do
+      Puppet::Util::Execution.expects(:execpipe).with(execpipe_args).yields StringIO.new([bash_installed_output, "foobar\n", vim_installed_output].join)
 
       bash = mock 'bash'
       vim = mock 'vim'
@@ -107,226 +58,134 @@ install ok installed vim 2:7.3.547-6ubuntu5 :DESC: Vi IMproved - enhanced vi edi
 
       expect(provider_class.instances).to eq([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)
-
-      expect(provider_class.instances).to eq([bash, vim])
-    end
   end
 
   describe "when querying the current state" do
-    let(:query_args) { args.push(resource_name) }
-
-    before do
-      provider.expects(:execute).never # forbid "manual" executions
+    let(:dpkgquery_path) { '/bin/dpkg-query' }
+    let(:query_args) do
+      args.unshift(dpkgquery_path)
+      args.push(resource_name)
     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))
+    def dpkg_query_execution_returns(output)
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).returns(output)
     end
 
-    it "should use exec-pipe" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields bash_installed_io
-
-      provider.query
+    before do
+      Puppet::Util.stubs(:which).with('/usr/bin/dpkg-query').returns(dpkgquery_path)
     end
 
-    it "should consider the package purged if dpkg-query fails" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).raises Puppet::ExecutionFailure.new("eh")
+    it "considers the package purged if dpkg-query fails" do
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("eh")
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
 
-    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
+    it "returns a hash of the found package status for an installed package" do
+      dpkg_query_execution_returns(bash_installed_output)
 
-      expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg, :description => "GNU Bourne Again SHell"})
+      expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
     end
 
-    it "should consider the package absent if the dpkg-query result cannot be interpreted" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields StringIO.new("somebaddata")
+    it "considers the package absent if the dpkg-query result cannot be interpreted" do
+      dpkg_query_execution_returns('some-bad-data')
 
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "should fail if an error is discovered" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("ok", "error")
+    it "fails if an error is discovered" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("ok","error"))
 
       expect { provider.query }.to raise_error(Puppet::Error)
     end
 
-    it "should consider the package purged if it is marked 'not-installed'" do
+    it "considers the package purged if it is marked 'not-installed'" do
       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)
+      dpkg_query_execution_returns(not_installed_bash)
 
       expect(provider.query[:ensure]).to eq(:purged)
     end
 
-    it "should consider the package absent if it is marked 'config-files'" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "config-files")
+    it "considers the package absent if it is marked 'config-files'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","config-files"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "should consider the package absent if it is marked 'half-installed'" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "half-installed")
+    it "considers the package absent if it is marked 'half-installed'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-installed"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "should consider the package absent if it is marked 'unpacked'" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "unpacked")
+    it "considers the package absent if it is marked 'unpacked'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","unpacked"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "should consider the package absent if it is marked 'half-configured'" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("installed", "half-configured")
+    it "considers the package absent if it is marked 'half-configured'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("installed","half-configured"))
       expect(provider.query[:ensure]).to eq(:absent)
     end
 
-    it "should consider the package held if its state is 'hold'" do
-      Puppet::Util::Execution.expects(:execpipe).with(query_args).yields replace_in_bash_output("install", "hold")
+    it "considers the package held if its state is 'hold'" do
+      dpkg_query_execution_returns(bash_installed_output.gsub("install","hold"))
       expect(provider.query[:ensure]).to eq(: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)
-      expect(provider_class.parse_multi_line(pipe)).to eq(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
-      expect(hash).to eq(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
-
-      expect(provider.query).to eq(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
+    describe "parsing tests" do
+      let(:resource_name) { 'name' }
+      let(:package_hash) do
+        {
+          :desired => 'desired',
+          :error => 'ok',
+          :status => 'status',
+          :name => resource_name,
+          :ensure => 'ensure',
+          :provider => :dpkg,
+        }
+      end
+      let(:package_not_found_hash) do
+        {:ensure => :purged, :status => 'missing', :name => resource_name, :error => 'ok'}
+      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
+      def parser_test(dpkg_output_string, gold_hash, number_of_debug_logs = 0)
+        dpkg_query_execution_returns(dpkg_output_string)
+        Puppet.expects(:warning).never
+        Puppet.expects(:debug).times(number_of_debug_logs)
 
-    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
+        expect(provider.query).to eq(gold_hash)
+      end
 
-    context "dpkg-query versions < 1.16" do
-      it "parses dpkg-query 1.15 reporting that package does not exist without warning about a failed match (#22529)" do
-        Puppet.expects(:warning).never
-        pipe = StringIO.new("No packages found matching non-existent-package")
-        Puppet::Util::Execution.expects(:execpipe).with(query_args).yields(pipe).raises(Puppet::ExecutionFailure.new('no package found'))
+      it "parses properly even if optional ensure field is missing" do
+        no_ensure = 'desired ok status name '
+        parser_test(no_ensure, package_hash.merge(:ensure => ''))
+      end
 
-        expect(provider.query).to eq({:ensure=>:purged, :status=>"missing", :name=>"name", :error=>"ok"})
+      it "provides debug logging of unparsable lines" do
+        parser_test('an unexpected dpkg msg with an exit code of 0', package_not_found_hash.merge(:ensure => :absent), 1)
       end
-    end
 
-    context "dpkg-query versions >= 1.16" do
-      it "parses dpkg-query 1.16 reporting that package does not exist without warning about a failed match (#22529)" do
-        Puppet.expects(:warning).never
-        pipe = StringIO.new("dpkg-query: no packages found matching non-existent-package")
-        Puppet::Util::Execution.expects(:execpipe).with(query_args).yields(pipe).raises(Puppet::ExecutionFailure.new('no package found'))
+      it "does not log if execution returns with non-zero exit code" do
+        Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).raises Puppet::ExecutionFailure.new("failed")
+        Puppet::expects(:debug).never
 
-        expect(provider.query).to eq({:ensure=>:purged, :status=>"missing", :name=>"name", :error=>"ok"})
+        expect(provider.query).to eq(package_not_found_hash)
       end
     end
   end
 
-  it "should be able to install" do
-    expect(provider).to respond_to(:install)
-  end
-
   describe "when installing" do
     before do
       resource.stubs(:[]).with(:source).returns "mypkg"
     end
 
-    it "should fail to install if no source is specified in the resource" do
+    it "fails to install if no source is specified in the resource" do
       resource.expects(:[]).with(:source).returns nil
 
       expect { provider.install }.to raise_error(ArgumentError)
     end
 
-    it "should use 'dpkg -i' to install the package" do
+    it "uses '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" }
@@ -334,7 +193,7 @@ desired ok status name ensure :DESC: summary text
       provider.install
     end
 
-    it "should keep old config files if told to do so" do
+    it "keeps 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" }
@@ -342,7 +201,7 @@ desired ok status name ensure :DESC: summary text
       provider.install
     end
 
-    it "should replace old config files if told to do so" do
+    it "replaces 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" }
@@ -350,7 +209,7 @@ desired ok status name ensure :DESC: summary text
       provider.install
     end
 
-    it "should ensure any hold is removed" do
+    it "ensures any hold is removed" do
       provider.expects(:unhold).once
       provider.expects(:dpkg)
       provider.install
@@ -365,44 +224,44 @@ desired ok status name ensure :DESC: summary text
       Tempfile.stubs(:new).returns tempfile
     end
 
-    it "should install first if holding" do
+    it "installs first if holding" do
       provider.stubs(:execute)
       provider.expects(:install).once
       provider.hold
     end
 
-    it "should execute dpkg --set-selections when holding" do
+    it "executes 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
     end
 
-    it "should execute dpkg --set-selections when unholding" do
+    it "executes 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
     end
   end
 
-  it "should use :install to update" do
+  it "uses :install to update" do
     provider.expects(:install)
     provider.update
   end
 
   describe "when determining latest available version" do
-    it "should return the version found by dpkg-deb" do
+    it "returns the version found by dpkg-deb" do
       resource.expects(:[]).with(:source).returns "myfile"
       provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "package\t1.0"
       expect(provider.latest).to eq("1.0")
     end
 
-    it "should warn if the package file contains a different package" do
+    it "warns if the package file contains a different package" do
       provider.expects(:dpkg_deb).returns("foo\tversion")
       provider.expects(:warning)
       provider.latest
     end
 
-    it "should cope with names containing ++" do
+    it "copes with names containing ++" do
       resource = stub 'resource', :[] => "package++"
       provider = provider_class.new(resource)
       provider.expects(:dpkg_deb).returns "package++\t1.0"
@@ -410,12 +269,12 @@ desired ok status name ensure :DESC: summary text
     end
   end
 
-  it "should use 'dpkg -r' to uninstall" do
+  it "uses 'dpkg -r' to uninstall" do
     provider.expects(:dpkg).with("-r", resource_name)
     provider.uninstall
   end
 
-  it "should use 'dpkg --purge' to purge" do
+  it "uses 'dpkg --purge' to purge" do
     provider.expects(:dpkg).with("--purge", resource_name)
     provider.purge
   end