puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/provider/package/windows/msi_package_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
 
   context '::installer', :if => Puppet.features.microsoft_windows? do
     it 'should return an instance of the COM interface' do
-      subject.installer.should_not be_nil
+      expect(subject.installer).not_to be_nil
     end
   end
 
@@ -30,16 +30,16 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
       expect_installer
 
       pkg = subject.from_registry(productcode, {'DisplayName' => name, 'DisplayVersion' => version})
-      pkg.name.should == name
-      pkg.version.should == version
-      pkg.productcode.should == productcode
-      pkg.packagecode.should == packagecode
+      expect(pkg.name).to eq(name)
+      expect(pkg.version).to eq(version)
+      expect(pkg.productcode).to eq(productcode)
+      expect(pkg.packagecode).to eq(packagecode)
     end
 
     it 'should return nil if it is not a valid MSI' do
       subject.expects(:valid?).returns(false)
 
-      subject.from_registry(productcode, {}).should be_nil
+      expect(subject.from_registry(productcode, {})).to be_nil
     end
   end
 
@@ -53,21 +53,21 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
     }.each_pair do |k, arr|
       it "should accept '#{k}' with value '#{arr[0]}'" do
         values[k] = arr[0]
-        subject.valid?(productcode, values).should be_true
+        expect(subject.valid?(productcode, values)).to be_truthy
       end
 
       it "should reject '#{k}' with value '#{arr[1]}'" do
         values[k] = arr[1]
-        subject.valid?(productcode, values).should be_false
+        expect(subject.valid?(productcode, values)).to be_falsey
       end
     end
 
     it 'should reject packages whose name is not a productcode' do
-     subject.valid?('AddressBook', values).should be_false
+     expect(subject.valid?('AddressBook', values)).to be_falsey
    end
 
    it 'should accept packages whose name is a productcode' do
-     subject.valid?(productcode, values).should be_true
+     expect(subject.valid?(productcode, values)).to be_truthy
    end
   end
 
@@ -75,25 +75,25 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
     it 'should match package codes case-insensitively' do
       pkg = subject.new(name, version, productcode, packagecode.upcase)
 
-      pkg.match?({:name => packagecode.downcase}).should be_true
+      expect(pkg.match?({:name => packagecode.downcase})).to be_truthy
     end
 
     it 'should match product codes case-insensitively' do
       pkg = subject.new(name, version, productcode.upcase, packagecode)
 
-      pkg.match?({:name => productcode.downcase}).should be_true
+      expect(pkg.match?({:name => productcode.downcase})).to be_truthy
     end
 
     it 'should match product name' do
       pkg = subject.new(name, version, productcode, packagecode)
 
-      pkg.match?({:name => name}).should be_true
+      expect(pkg.match?({:name => name})).to be_truthy
     end
 
     it 'should return false otherwise' do
       pkg = subject.new(name, version, productcode, packagecode)
 
-      pkg.match?({:name => 'not going to find it'}).should be_false
+      expect(pkg.match?({:name => 'not going to find it'})).to be_falsey
     end
   end
 
@@ -101,7 +101,7 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
     it 'should install using the source' do
       cmd = subject.install_command({:source => source})
 
-      cmd.should == ['msiexec.exe', '/qn', '/norestart', '/i', source]
+      expect(cmd).to eq(['msiexec.exe', '/qn', '/norestart', '/i', source])
     end
   end
 
@@ -109,7 +109,7 @@ describe Puppet::Provider::Package::Windows::MsiPackage do
     it 'should uninstall using the productcode' do
       pkg = subject.new(name, version, productcode, packagecode)
 
-      pkg.uninstall_command.should == ['msiexec.exe', '/qn', '/norestart', '/x', productcode]
+      expect(pkg.uninstall_command).to eq(['msiexec.exe', '/qn', '/norestart', '/x', productcode])
     end
   end
 end

data/spec/unit/provider/package/windows/package_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Provider::Package::Windows::Package do
     it 'should generate an empty enumeration' do
       subject.expects(:with_key)
 
-      subject.to_a.should be_empty
+      expect(subject.to_a).to be_empty
     end
 
     it 'should yield each package it finds' do
@@ -28,7 +28,7 @@ describe Puppet::Provider::Package::Windows::Package do
         yielded = pkg
       end
 
-      yielded.should == package
+      expect(yielded).to eq(package)
     end
   end
 
@@ -52,7 +52,7 @@ describe Puppet::Provider::Package::Windows::Package do
 
       keys = []
       subject.with_key { |key, values| keys << key }
-      keys.should be_empty
+      expect(keys).to be_empty
     end
 
     it 'should raise other types of exceptions' do
@@ -76,15 +76,15 @@ describe Puppet::Provider::Package::Windows::Package do
       let (:klass) { Puppet::Provider::Package::Windows::MsiPackage }
 
       it 'should accept source ending in .msi' do
-        subject.installer_class({:source => 'foo.msi'}).should == klass
+        expect(subject.installer_class({:source => 'foo.msi'})).to eq(klass)
       end
 
       it 'should accept quoted source ending in .msi' do
-        subject.installer_class({:source => '"foo.msi"'}).should == klass
+        expect(subject.installer_class({:source => '"foo.msi"'})).to eq(klass)
       end
 
       it 'should accept source case insensitively' do
-        subject.installer_class({:source => '"foo.MSI"'}).should == klass
+        expect(subject.installer_class({:source => '"foo.MSI"'})).to eq(klass)
       end
 
       it 'should reject source containing msi in the name' do
@@ -105,37 +105,37 @@ describe Puppet::Provider::Package::Windows::Package do
 
   context '::munge' do
     it 'should shell quote strings with spaces and fix forward slashes' do
-      subject.munge('c:/windows/the thing').should == '"c:\windows\the thing"'
+      expect(subject.munge('c:/windows/the thing')).to eq('"c:\windows\the thing"')
     end
     it 'should leave properly formatted paths alone' do
-      subject.munge('c:\windows\thething').should == 'c:\windows\thething'
+      expect(subject.munge('c:\windows\thething')).to eq('c:\windows\thething')
     end
   end
 
   context '::replace_forward_slashes' do
     it 'should replace forward with back slashes' do
-      subject.replace_forward_slashes('c:/windows/thing/stuff').should == 'c:\windows\thing\stuff'
+      expect(subject.replace_forward_slashes('c:/windows/thing/stuff')).to eq('c:\windows\thing\stuff')
     end
   end
 
   context '::quote' do
     it 'should shell quote strings with spaces' do
-      subject.quote('foo bar').should == '"foo bar"'
+      expect(subject.quote('foo bar')).to eq('"foo bar"')
     end
 
     it 'should shell quote strings with spaces and quotes' do
-      subject.quote('"foo bar" baz').should == '"\"foo bar\" baz"'
+      expect(subject.quote('"foo bar" baz')).to eq('"\"foo bar\" baz"')
     end
 
     it 'should not shell quote strings without spaces' do
-      subject.quote('"foobar"').should == '"foobar"'
+      expect(subject.quote('"foobar"')).to eq('"foobar"')
     end
   end
 
   it 'should implement instance methods' do
     pkg = subject.new('orca', '5.0')
 
-    pkg.name.should == 'orca'
-    pkg.version.should == '5.0'
+    expect(pkg.name).to eq('orca')
+    expect(pkg.version).to eq('5.0')
   end
 end

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

@@ -18,16 +18,16 @@ describe Puppet::Type.type(:package).provider(:windows) do
   end
 
   describe 'provider features' do
-    it { should be_installable }
-    it { should be_uninstallable }
-    it { should be_install_options }
-    it { should be_uninstall_options }
-    it { should be_versionable }
+    it { is_expected.to be_installable }
+    it { is_expected.to be_uninstallable }
+    it { is_expected.to be_install_options }
+    it { is_expected.to be_uninstall_options }
+    it { is_expected.to be_versionable }
   end
 
   describe 'on Windows', :if => Puppet.features.microsoft_windows? do
     it 'should be the default provider' do
-      Puppet::Type.type(:package).defaultprovider.should == subject.class
+      expect(Puppet::Type.type(:package).defaultprovider).to eq(subject.class)
     end
   end
 
@@ -42,20 +42,20 @@ describe Puppet::Type.type(:package).provider(:windows) do
       Puppet::Provider::Package::Windows::Package.expects(:map).multiple_yields([prov1], [prov2]).returns([prov1, prov2])
 
       providers = provider.class.instances
-      providers.count.should == 2
-      providers[0].name.should == 'pkg1'
-      providers[0].version.should == '1.0.0'
-      providers[0].package.should == pkg1
+      expect(providers.count).to eq(2)
+      expect(providers[0].name).to eq('pkg1')
+      expect(providers[0].version).to eq('1.0.0')
+      expect(providers[0].package).to eq(pkg1)
 
-      providers[1].name.should == 'pkg2'
-      providers[1].version.should be_nil
-      providers[1].package.should == pkg2
+      expect(providers[1].name).to eq('pkg2')
+      expect(providers[1].version).to be_nil
+      expect(providers[1].package).to eq(pkg2)
     end
 
     it 'should return an empty array if none found' do
       Puppet::Provider::Package::Windows::Package.expects(:map).returns([])
 
-      provider.class.instances.should == []
+      expect(provider.class.instances).to eq([])
     end
   end
 
@@ -65,7 +65,7 @@ describe Puppet::Type.type(:package).provider(:windows) do
       pkg.expects(:match?).returns(true)
       Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
-      provider.query.should == { :name => 'pkg1', :ensure => :installed, :provider => :windows }
+      expect(provider.query).to eq({ :name => 'pkg1', :ensure => :installed, :provider => :windows })
     end
 
     it 'should include the version string when present' do
@@ -73,13 +73,13 @@ describe Puppet::Type.type(:package).provider(:windows) do
       pkg.expects(:match?).returns(true)
       Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
-      provider.query.should == { :name => 'pkg1', :ensure => '1.0.0', :provider => :windows }
+      expect(provider.query).to eq({ :name => 'pkg1', :ensure => '1.0.0', :provider => :windows })
     end
 
     it 'should return nil if no package was found' do
       Puppet::Provider::Package::Windows::Package.expects(:find)
 
-      provider.query.should be_nil
+      expect(provider.query).to be_nil
     end
   end
 
@@ -201,51 +201,51 @@ describe Puppet::Type.type(:package).provider(:windows) do
 
   context '#install_options' do
     it 'should return nil by default' do
-      provider.install_options.should be_nil
+      expect(provider.install_options).to be_nil
     end
 
     it 'should return the options' do
       resource[:install_options] = { 'INSTALLDIR' => 'C:\mysql-here' }
 
-      provider.install_options.should == ['INSTALLDIR=C:\mysql-here']
+      expect(provider.install_options).to eq(['INSTALLDIR=C:\mysql-here'])
     end
 
     it 'should only quote if needed' do
       resource[:install_options] = { 'INSTALLDIR' => 'C:\mysql here' }
 
-      provider.install_options.should == ['INSTALLDIR="C:\mysql here"']
+      expect(provider.install_options).to eq(['INSTALLDIR="C:\mysql here"'])
     end
 
     it 'should escape embedded quotes in install_options values with spaces' do
       resource[:install_options] = { 'INSTALLDIR' => 'C:\mysql "here"' }
 
-      provider.install_options.should == ['INSTALLDIR="C:\mysql \"here\""']
+      expect(provider.install_options).to eq(['INSTALLDIR="C:\mysql \"here\""'])
     end
   end
 
   context '#uninstall_options' do
     it 'should return nil by default' do
-      provider.uninstall_options.should be_nil
+      expect(provider.uninstall_options).to be_nil
     end
 
     it 'should return the options' do
       resource[:uninstall_options] = { 'INSTALLDIR' => 'C:\mysql-here' }
 
-      provider.uninstall_options.should == ['INSTALLDIR=C:\mysql-here']
+      expect(provider.uninstall_options).to eq(['INSTALLDIR=C:\mysql-here'])
     end
   end
 
   context '#join_options' do
     it 'should return nil if there are no options' do
-      provider.join_options(nil).should be_nil
+      expect(provider.join_options(nil)).to be_nil
     end
 
     it 'should sort hash keys' do
-      provider.join_options([{'b' => '2', 'a' => '1', 'c' => '3'}]).should == ['a=1', 'b=2', 'c=3']
+      expect(provider.join_options([{'b' => '2', 'a' => '1', 'c' => '3'}])).to eq(['a=1', 'b=2', 'c=3'])
     end
 
     it 'should return strings and hashes' do
-      provider.join_options([{'a' => '1'}, 'b']).should == ['a=1', 'b']
+      expect(provider.join_options([{'a' => '1'}, 'b'])).to eq(['a=1', 'b'])
     end
   end
 end

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

@@ -4,6 +4,8 @@ require 'spec_helper'
 provider_class = Puppet::Type.type(:package).provider(:yum)
 
 describe provider_class do
+  include PuppetSpec::Fixtures
+
   let(:name) { 'mypackage' }
   let(:resource) do
     Puppet::Type.type(:package).new(
@@ -28,16 +30,150 @@ describe provider_class do
   end
 
   describe 'provider features' do
-    it { should be_versionable }
-    it { should be_install_options }
-    it { should be_virtual_packages }
+    it { is_expected.to be_versionable }
+    it { is_expected.to be_install_options }
+    it { is_expected.to be_virtual_packages }
   end
 
   # provider should repond to the following methods
    [:install, :latest, :update, :purge, :install_options].each do |method|
      it "should have a(n) #{method}" do
-       provider.should respond_to(method)
+       expect(provider).to respond_to(method)
+    end
+  end
+
+  describe 'package evr parsing' do
+
+    it 'should parse full simple evr' do
+      v = provider.yum_parse_evr('0:1.2.3-4.el5')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.el5')
+    end
+
+    it 'should parse version only' do
+      v = provider.yum_parse_evr('1.2.3')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq(nil)
+    end
+
+    it 'should parse version-release' do
+      v = provider.yum_parse_evr('1.2.3-4.5.el6')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.5.el6')
+    end
+
+    it 'should parse release with git hash' do
+      v = provider.yum_parse_evr('1.2.3-4.1234aefd')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.1234aefd')
+    end
+
+    it 'should parse single integer versions' do
+      v = provider.yum_parse_evr('12345')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('12345')
+      expect(v[:release]).to eq(nil)
+    end
+
+    it 'should parse text in the epoch to 0' do
+      v = provider.yum_parse_evr('foo0:1.2.3-4')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4')
+    end
+
+    it 'should parse revisions with text' do
+      v = provider.yum_parse_evr('1.2.3-SNAPSHOT20140107')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('SNAPSHOT20140107')
+    end
+
+    # test cases for PUP-682
+    it 'should parse revisions with text and numbers' do
+      v = provider.yum_parse_evr('2.2-SNAPSHOT20121119105647')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('2.2')
+      expect(v[:release]).to eq('SNAPSHOT20121119105647')
+    end
+
+  end
+
+  describe 'yum evr comparison' do
+
+    # currently passing tests
+    it 'should evaluate identical version-release as equal' do
+      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '1.el5'})
+      expect(v).to eq(0)
     end
+
+    it 'should evaluate identical version as equal' do
+      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
+                                  {:epoch => '0', :version => '1.2.3', :release => nil})
+      expect(v).to eq(0)
+    end
+
+    it 'should evaluate identical version but older release as less' do
+      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(-1)
+    end
+
+    it 'should evaluate identical version but newer release as greater' do
+      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => '3.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(1)
+    end
+
+    it 'should evaluate a newer epoch as greater' do
+      v = provider.yum_compareEVR({:epoch => '1', :version => '1.2.3', :release => '4.5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '4.5'})
+      expect(v).to eq(1)
+    end
+
+    # these tests describe PUP-1244 logic yet to be implemented
+    it 'should evaluate any version as equal to the same version followed by release' do
+      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(0)
+    end
+
+    # test cases for PUP-682
+    it 'should evaluate same-length numeric revisions numerically' do
+      expect(provider.yum_compareEVR({:epoch => '0', :version => '2.2', :release => '405'},
+                               {:epoch => '0', :version => '2.2', :release => '406'})).to eq(-1)
+    end
+
+  end
+
+  describe 'yum version segment comparison' do
+
+    it 'should treat two nil values as equal' do
+      v = provider.compare_values(nil, nil)
+      expect(v).to eq(0)
+    end
+
+    it 'should treat a nil value as less than a non-nil value' do
+      v = provider.compare_values(nil, '0')
+      expect(v).to eq(-1)
+    end
+
+    it 'should treat a non-nil value as greater than a nil value' do
+      v = provider.compare_values('0', nil)
+      expect(v).to eq(1)
+    end
+
+    it 'should pass two non-nil values on to rpmvercmp' do
+      provider.stubs(:rpmvercmp) { 0 }
+      provider.expects(:rpmvercmp).with('s1', 's2')
+      provider.compare_values('s1', 's2')
+    end
+
   end
 
   describe 'when installing' do
@@ -49,7 +185,6 @@ describe provider_class do
 
     it 'should call yum install for :installed' do
       resource.stubs(:should).with(:ensure).returns :installed
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name)
       provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, name)
       provider.install
     end
@@ -62,12 +197,18 @@ describe provider_class do
     it 'should be able to set version' do
       version = '1.2'
       resource[:ensure] = version
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :list, name)
       provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}")
       provider.stubs(:query).returns :ensure => version
       provider.install
     end
 
+    it 'should handle partial versions specified' do
+      version = '1.3.4'
+      resource[:ensure] = version
+      provider.stubs(:query).returns :ensure => '1.3.4-1.el6'
+      provider.install
+    end
+
     it 'should be able to downgrade' do
       current_version = '1.2'
       version = '1.0'
@@ -81,7 +222,6 @@ describe provider_class do
       resource[:ensure] = :installed
       resource[:install_options] = ['-t', {'-x' => 'expackage'}]
 
-      provider.expects(:yum).with('-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :list, name)
       provider.expects(:yum).with('-d', '0', '-e', '0', '-y', ['-t', '-x=expackage'], :install, name)
       provider.install
     end
@@ -103,7 +243,7 @@ describe provider_class do
   end
 
   it 'should be versionable' do
-    provider.should be_versionable
+    expect(provider).to be_versionable
   end
 
   describe 'determining the latest version available for a package' do
@@ -115,7 +255,7 @@ describe provider_class do
       ]
       provider.stubs(:properties).returns({:ensure => '3.4.5'})
 
-      described_class.expects(:latest_package_version).with(name, ['contrib', 'centosplus'], [])
+      described_class.expects(:latest_package_version).with(name, ['contrib', 'centosplus'], [], [])
       provider.latest
     end
 
@@ -126,13 +266,24 @@ describe provider_class do
       ]
       provider.stubs(:properties).returns({:ensure => '3.4.5'})
 
-      described_class.expects(:latest_package_version).with(name, [], ['updates', 'centosplus'])
+      described_class.expects(:latest_package_version).with(name, [], ['updates', 'centosplus'], [])
+      provider.latest
+    end
+
+    it "passes the value of disableexcludes install_options when querying" do
+      resource[:install_options] = [
+        {'--disableexcludes' => 'main'},
+        {'--disableexcludes' => 'centosplus'},
+      ]
+      provider.stubs(:properties).returns({:ensure => '3.4.5'})
+
+      described_class.expects(:latest_package_version).with(name, [], [], ['main', 'centosplus'])
       provider.latest
     end
 
     describe 'and a newer version is not available' do
       before :each do
-        described_class.stubs(:latest_package_version).with(name, [], []).returns nil
+        described_class.stubs(:latest_package_version).with(name, [], [], []).returns nil
       end
 
       it 'raises an error the package is not installed' do
@@ -144,7 +295,7 @@ describe provider_class do
 
       it 'returns version of the currently installed package' do
         provider.stubs(:properties).returns({:ensure => '3.4.5'})
-        provider.latest.should == '3.4.5'
+        expect(provider.latest).to eq('3.4.5')
       end
     end
 
@@ -160,8 +311,8 @@ describe provider_class do
       end
 
       it 'includes the epoch in the version string' do
-        described_class.stubs(:latest_package_version).with(name, [], []).returns(latest_version)
-        provider.latest.should == '1:2.3.4-5'
+        described_class.stubs(:latest_package_version).with(name, [], [], []).returns(latest_version)
+        expect(provider.latest).to eq('1:2.3.4-5')
       end
     end
   end
@@ -194,115 +345,158 @@ describe provider_class do
     let(:enabled_versions) { {name => [mypackage_newerversion]} }
 
     it "returns the version hash if the package was found" do
-      described_class.expects(:fetch_latest_versions).with([], []).once.returns(latest_versions)
-      version = described_class.latest_package_version(name, [], [])
+      described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+      version = described_class.latest_package_version(name, [], [], [])
       expect(version).to eq(mypackage_version)
     end
 
     it "is nil if the package was not found in the query" do
-      described_class.expects(:fetch_latest_versions).with([], []).once.returns(latest_versions)
-      version = described_class.latest_package_version('nopackage', [], [])
+      described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+      version = described_class.latest_package_version('nopackage', [], [], [])
       expect(version).to be_nil
     end
 
     it "caches the package list and reuses that for subsequent queries" do
-      described_class.expects(:fetch_latest_versions).with([], []).once.returns(latest_versions)
+      described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
 
       2.times {
-        version = described_class.latest_package_version(name, [], [])
+        version = described_class.latest_package_version(name, [], [], [])
         expect(version).to eq mypackage_version
       }
     end
 
-    it "caches separate lists for each combination of 'enablerepo' and 'disablerepo'" do
-      described_class.expects(:fetch_latest_versions).with([], []).once.returns(latest_versions)
-      described_class.expects(:fetch_latest_versions).with(['enabled'], ['disabled']).once.returns(enabled_versions)
+    it "caches separate lists for each combination of 'enablerepo' and 'disablerepo' and 'disableexcludes'" do
+      described_class.expects(:check_updates).with([], [], []).once.returns(latest_versions)
+      described_class.expects(:check_updates).with(['enabled'], ['disabled'], ['disableexcludes']).once.returns(enabled_versions)
 
       2.times {
-        version = described_class.latest_package_version(name, [], [])
+        version = described_class.latest_package_version(name, [], [], [])
         expect(version).to eq mypackage_version
       }
 
       2.times {
-        version = described_class.latest_package_version(name, ['enabled'], ['disabled'])
+        version = described_class.latest_package_version(name, ['enabled'], ['disabled'], ['disableexcludes'])
         expect(version).to eq(mypackage_newerversion)
       }
     end
   end
 
-  describe "querying for the latest version of all packages" do
-    let(:yumhelper_single_arch) do
-      <<-YUMHELPER_OUTPUT
- * base: centos.tcpdiag.net
- * extras: centos.mirrors.hoobly.com
- * updates: mirrors.arsc.edu
-_pkg nss-tools 0 3.14.3 4.el6_4 x86_64
-_pkg pixman 0 0.26.2 5.el6_4 x86_64
-_pkg myresource 0 1.2.3.4 5.el4 noarch
-_pkg mysummaryless 0 1.2.3.4 5.el4 noarch
-     YUMHELPER_OUTPUT
-    end
-
-    let(:yumhelper_multi_arch) do
-      yumhelper_single_arch + <<-YUMHELPER_OUTPUT
-_pkg nss-tools 0 3.14.3 4.el6_4 i386
-_pkg pixman 0 0.26.2 5.el6_4 i386
-      YUMHELPER_OUTPUT
-    end
-
-
-    it "creates an entry for each line that's prefixed with '_pkg'" do
-      described_class.expects(:python).with([described_class::YUMHELPER]).returns(yumhelper_single_arch)
-      entries = described_class.fetch_latest_versions([], [])
-      expect(entries.keys).to include 'nss-tools'
-      expect(entries.keys).to include 'pixman'
-      expect(entries.keys).to include 'myresource'
-      expect(entries.keys).to include 'mysummaryless'
-    end
-
-    it "creates an entry for each package name and architecture" do
-      described_class.expects(:python).with([described_class::YUMHELPER]).returns(yumhelper_single_arch)
-      entries = described_class.fetch_latest_versions([], [])
-      expect(entries.keys).to include 'nss-tools.x86_64'
-      expect(entries.keys).to include 'pixman.x86_64'
-      expect(entries.keys).to include 'myresource.noarch'
-      expect(entries.keys).to include 'mysummaryless.noarch'
-    end
-
-    it "stores multiple entries if a package is build for multiple architectures" do
-      described_class.expects(:python).with([described_class::YUMHELPER]).returns(yumhelper_multi_arch)
-      entries = described_class.fetch_latest_versions([], [])
-      expect(entries.keys).to include 'nss-tools.x86_64'
-      expect(entries.keys).to include 'pixman.x86_64'
-      expect(entries.keys).to include 'nss-tools.i386'
-      expect(entries.keys).to include 'pixman.i386'
-
-      expect(entries['nss-tools']).to have(2).items
-      expect(entries['pixman']).to have(2).items
-    end
-
-    it "passes the repos to enable to the helper" do
-      described_class.expects(:python).with do |script, *args|
-        expect(script).to eq described_class::YUMHELPER
-        expect(args).to eq %w[-e updates -e centosplus]
-      end.returns('')
-      described_class.fetch_latest_versions(['updates', 'centosplus'], [])
-    end
-
-    it "passes the repos to disable to the helper" do
-      described_class.expects(:python).with do |script, *args|
-        expect(script).to eq described_class::YUMHELPER
-        expect(args).to eq %w[-d updates -d centosplus]
-      end.returns('')
-      described_class.fetch_latest_versions([], ['updates', 'centosplus'])
-    end
-
-    it 'passes a combination of repos to the helper' do
-      described_class.expects(:python).with do |script, *args|
-        expect(script).to eq described_class::YUMHELPER
-        expect(args).to eq %w[-e os -e contrib -d updates -d centosplus]
-      end.returns('')
-      described_class.fetch_latest_versions(['os', 'contrib'], ['updates', 'centosplus'])
+  describe "executing yum check-update" do
+    before do
+      described_class.stubs(:command).with(:yum).returns '/usr/bin/yum'
+    end
+
+    it "passes repos to enable to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/yum check-update --enablerepo=updates --enablerepo=centosplus]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates(%w[updates centosplus], [], [])
+    end
+
+    it "passes repos to disable to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/yum check-update --disablerepo=updates --disablerepo=centosplus]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates([],%w[updates centosplus], [])
+    end
+
+    it "passes a combination of repos to enable and disable to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/yum check-update --enablerepo=os --enablerepo=contrib --disablerepo=updates --disablerepo=centosplus]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates(%w[os contrib], %w[updates centosplus], [])
+    end
+
+    it "passes disableexcludes to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/yum check-update --disableexcludes=main --disableexcludes=centosplus]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates([], [], %w[main centosplus])
+    end
+
+    it "passes all options to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/yum check-update --enablerepo=a --enablerepo=b --disablerepo=c
+                              --disablerepo=d --disableexcludes=e --disableexcludes=f]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates(%w[a b], %w[c d], %w[e f])
+    end
+
+    it "returns an empty hash if 'yum check-update' returned 0" do
+      Puppet::Util::Execution.expects(:execute).returns(stub :exitstatus => 0)
+      expect(described_class.check_updates([], [], [])).to be_empty
+    end
+
+    it "returns a populated hash if 'yum check-update returned 100'" do
+      output = stub(:exitstatus => 100)
+      Puppet::Util::Execution.expects(:execute).returns(output)
+      described_class.expects(:parse_updates).with(output).returns({:has => :updates})
+      expect(described_class.check_updates([], [], [])).to eq({:has => :updates})
+    end
+
+    it "returns an empty hash if 'yum check-update' returned an exit code that was not 0 or 100" do
+      Puppet::Util::Execution.expects(:execute).returns(stub(:exitstatus => 1))
+      described_class.expects(:warn)
+      expect(described_class.check_updates([], [], [])).to eq({})
+    end
+  end
+
+  describe "parsing the output of check-update" do
+
+    describe "with no multiline entries" do
+      let(:check_update) { File.read(my_fixture('yum-check-update-simple.txt')) }
+      let(:output) { described_class.parse_updates(check_update) }
+
+      it 'creates an entry for each package keyed on the package name' do
+        expect(output['curl']).to eq([{:name => 'curl', :epoch => '0', :version => '7.32.0', :release => '10.fc20', :arch => 'i686'}, {:name => 'curl', :epoch => '0', :version => '7.32.0', :release => '10.fc20', :arch => 'x86_64'}])
+        expect(output['gawk']).to eq([{:name => 'gawk', :epoch => '0', :version => '4.1.0', :release => '3.fc20', :arch => 'i686'}])
+        expect(output['dhclient']).to eq([{:name => 'dhclient', :epoch => '12', :version => '4.1.1', :release => '38.P1.fc20', :arch => 'i686'}])
+        expect(output['selinux-policy']).to eq([{:name => 'selinux-policy', :epoch => '0', :version => '3.12.1', :release => '163.fc20', :arch => 'noarch'}])
+      end
+
+      it 'creates an entry for each package keyed on the package name and package architecture' do
+        expect(output['curl.i686']).to eq([{:name => 'curl', :epoch => '0', :version => '7.32.0', :release => '10.fc20', :arch => 'i686'}])
+        expect(output['curl.x86_64']).to eq([{:name => 'curl', :epoch => '0', :version => '7.32.0', :release => '10.fc20', :arch => 'x86_64'}])
+        expect(output['gawk.i686']).to eq([{:name => 'gawk', :epoch => '0', :version => '4.1.0', :release => '3.fc20', :arch => 'i686'}])
+        expect(output['dhclient.i686']).to eq([{:name => 'dhclient', :epoch => '12', :version => '4.1.1', :release => '38.P1.fc20', :arch => 'i686'}])
+        expect(output['selinux-policy.noarch']).to eq([{:name => 'selinux-policy', :epoch => '0', :version => '3.12.1', :release => '163.fc20', :arch => 'noarch'}])
+      end
+    end
+
+    describe "with multiline entries" do
+      let(:check_update) { File.read(my_fixture('yum-check-update-multiline.txt')) }
+      let(:output) { described_class.parse_updates(check_update) }
+
+      it "parses multi-line values as a single package tuple" do
+        expect(output['libpcap']).to eq([{:name => 'libpcap', :epoch => '14', :version => '1.4.0', :release => '1.20130826git2dbcaa1.el6', :arch => 'x86_64'}])
+      end
+    end
+  end
+
+  describe "parsing a line from yum check-update" do
+    it "splits up the package name and architecture fields" do
+      checkupdate = %w[curl.i686 7.32.0-10.fc20]
+
+      parsed = described_class.update_to_hash(*checkupdate)
+      expect(parsed[:name]).to eq 'curl'
+      expect(parsed[:arch]).to eq 'i686'
+    end
+
+    it "splits up the epoch, version, and release fields" do
+      checkupdate = %w[dhclient.i686 12:4.1.1-38.P1.el6.centos]
+      parsed = described_class.update_to_hash(*checkupdate)
+      expect(parsed[:epoch]).to eq '12'
+      expect(parsed[:version]).to eq '4.1.1'
+      expect(parsed[:release]).to eq '38.P1.el6.centos'
+    end
+
+    it "sets the epoch to 0 when an epoch is not specified" do
+      checkupdate = %w[curl.i686 7.32.0-10.fc20]
+
+      parsed = described_class.update_to_hash(*checkupdate)
+      expect(parsed[:epoch]).to eq '0'
+      expect(parsed[:version]).to eq '7.32.0'
+      expect(parsed[:release]).to eq '10.fc20'
     end
   end
 end