puppet 5.5.17-x64-mingw32 → 5.5.22-x64-mingw32

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

@@ -395,4 +395,21 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
       end
     end
   end
+
+  context "#flavor" do
+    before do
+      provider.instance_variable_get('@property_hash')[:flavor] = 'no_x11-python'
+    end
+
+    it 'should return the existing flavor' do
+      expect(provider.flavor).to eq('no_x11-python')
+    end
+
+    it 'should remove and install the new flavor if different' do
+      provider.resource[:flavor] = 'no_x11-ruby'
+      expect(provider).to receive(:uninstall).ordered
+      expect(provider).to receive(:install).ordered
+      provider.flavor = provider.resource[:flavor]
+    end
+  end
 end

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

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
-osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python'] }
+osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python', 'pip2', 'pip-2'] }
+pip_path_with_spaces = 'C:\Program Files (x86)\Python\Scripts\pip.exe'
 
 describe Puppet::Type.type(:package).provider(:pip) do
 
@@ -93,6 +94,16 @@ describe Puppet::Type.type(:package).provider(:pip) do
         expect(described_class.instances).to eq([])
       end
     end
+
+    context "when pip path location contains spaces" do
+      it "should quote the command before doing execpipe" do
+        allow(described_class).to receive(:which).and_return(pip_path_with_spaces)
+        allow(described_class).to receive(:pip_version).with(pip_path_with_spaces).and_return('8.0.1')
+
+        expect(described_class).to receive(:execpipe).with(["\"#{pip_path_with_spaces}\"", ["freeze"]])
+        described_class.instances
+      end
+    end
   end
 
   context "query" do
@@ -143,15 +154,18 @@ describe Puppet::Type.type(:package).provider(:pip) do
   end
 
   context "latest" do
+    before do
+      allow(described_class).to receive(:pip_version).with(pip_path).and_return(pip_version)
+      allow(described_class).to receive(:which).with('pip').and_return(pip_path)
+      allow(described_class).to receive(:which).with('pip-python').and_return(pip_path)
+      allow(described_class).to receive(:which).with('pip.exe').and_return(pip_path)
+      allow(described_class).to receive(:provider_command).and_return(pip_path)
+      allow(described_class).to receive(:validate_command).with(pip_path)
+    end
+
     context "with pip version < 1.5.4" do
-      before :each do
-        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.0.1')
-        allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
-      end
+      let(:pip_version) { '1.0.1' }
+      let(:pip_path) { '/fake/bin/pip' }
 
       it "should find a version number for new_pip_package" do
         p = StringIO.new(
@@ -197,19 +211,29 @@ describe Puppet::Type.type(:package).provider(:pip) do
         @resource[:name] = "fake_package"
         expect(@provider.latest).to eq(nil)
       end
+
+      it "should use 'install_options' when specified" do
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including([["--index=https://fake.example.com"]])).once
+        @resource[:name] = "fake_package"
+        @resource[:install_options] = ['--index' => 'https://fake.example.com']
+        expect(@provider.latest).to eq(nil)
+      end
+
+      context "when pip path location contains spaces" do
+        let(:pip_path) { pip_path_with_spaces }
+
+        it "should quote the command before doing execpipe" do
+          expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including("\"#{pip_path}\""))
+          @provider.latest
+        end
+      end
     end
 
     context "with pip version >= 1.5.4" do
       # For Pip 1.5.4 and above, you can get a version list from CLI - which allows for native pip behavior
       # with regards to custom repositories, proxies and the like
-      before :each do
-        allow(described_class).to receive(:pip_version).with("/fake/bin/pip").and_return('1.5.4')
-        allow(described_class).to receive(:which).with('pip').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip-python').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:which).with('pip.exe').and_return("/fake/bin/pip")
-        allow(described_class).to receive(:provider_command).and_return('/fake/bin/pip')
-        allow(described_class).to receive(:validate_command).with('/fake/bin/pip')
-      end
+      let(:pip_version) { '1.5.4' }
+      let(:pip_path) { '/fake/bin/pip' }
 
       it "should find a version number for real_package" do
         p = StringIO.new(
@@ -251,6 +275,22 @@ describe Puppet::Type.type(:package).provider(:pip) do
         latest = @provider.latest
         expect(latest).to eq('15.0.2')
       end
+
+      it "should use 'install_options' when specified" do
+        expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including([["--index=https://fake.example.com"]])).once
+        @resource[:name] = "fake_package"
+        @resource[:install_options] = ['--index' => 'https://fake.example.com']
+        expect(@provider.latest).to eq(nil)
+      end
+
+      context "when pip path location contains spaces" do
+        let(:pip_path) { pip_path_with_spaces }
+
+        it "should quote the command before doing execpipe" do
+          expect(Puppet::Util::Execution).to receive(:execpipe).with(array_including("\"#{pip_path}\""))
+          @provider.latest
+        end
+      end
     end
   end
 
@@ -341,12 +381,43 @@ describe Puppet::Type.type(:package).provider(:pip) do
   end
 
   context "pip_version" do
+    let(:pip) { '/fake/bin/pip' }
+
     it "should look up version if pip is present" do
-      allow(described_class).to receive(:pip_cmd).and_return('/fake/bin/pip')
-      p = double("process")
-      expect(p).to receive(:collect).and_yield('pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)')
-      expect(described_class).to receive(:execpipe).with(['/fake/bin/pip', '--version']).and_yield(p)
-      expect(described_class.pip_version('/fake/bin/pip')).to eq('8.0.2')
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      process = ['pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)']
+      allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield(process)
+
+      expect(described_class.pip_version(pip)).to eq('8.0.2')
+    end
+
+    it "parses multiple lines of output" do
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      process = [
+        "/usr/local/lib/python2.7/dist-packages/urllib3/contrib/socks.py:37: DependencyWarning: SOCKS support in urllib3 requires the installation of optional dependencies: specifically, PySocks. For more information, see https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies",
+        "  DependencyWarning",
+        "pip 1.5.6 from /usr/lib/python2.7/dist-packages (python 2.7)"
+      ]
+      allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield(process)
+
+      expect(described_class.pip_version(pip)).to eq('1.5.6')
+    end
+
+    it "raises if there isn't a version string" do
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield([""])
+      expect {
+        described_class.pip_version(pip)
+      }.to raise_error(Puppet::Error, 'Cannot resolve pip version')
+    end
+
+    it "quotes commands with spaces" do
+      pip = 'C:\Program Files\Python27\Scripts\pip.exe'
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
+      process = ["pip 18.1 from c:\program files\python27\lib\site-packages\pip (python 2.7)\r\n"]
+      allow(described_class).to receive(:execpipe).with(["\"#{pip}\"", '--version']).and_yield(process)
+
+      expect(described_class.pip_version(pip)).to eq('18.1')
     end
   end
 

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

@@ -90,7 +90,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
       {
         'pkg://omnios/SUNWcs@0.5.11,5.11-0.151006:20130506T161045Z    i--' => {:name => 'SUNWcs', :ensure => '0.5.11,5.11-0.151006:20130506T161045Z', :status => 'installed', :provider => :pkg, :publisher => 'omnios'},
-        'pkg://omnios/incorporation/jeos/illumos-gate@11,5.11-0.151006:20130506T183443Z if-' => {:name => 'incorporation/jeos/illumos-gate', :ensure => 'held', :status => 'installed', :provider => :pkg, :publisher => 'omnios'},
+        'pkg://omnios/incorporation/jeos/illumos-gate@11,5.11-0.151006:20130506T183443Z if-' => {:name => 'incorporation/jeos/illumos-gate', :ensure => "11,5.11-0.151006:20130506T183443Z", :mark => :hold, :status => 'installed', :provider => :pkg, :publisher => 'omnios'},
         'pkg://solaris/SUNWcs@0.5.11,5.11-0.151.0.1:20101105T001108Z      installed  -----' => {:name => 'SUNWcs', :ensure => '0.5.11,5.11-0.151.0.1:20101105T001108Z', :status => 'installed', :provider => :pkg, :publisher => 'solaris'},
        }.each do |k, v|
         it "[#{k}] should correctly parse" do
@@ -251,6 +251,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
           it "should accept all licenses" do
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
@@ -265,6 +266,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             # Should install also check if the version installed is the same version we are asked to install? or should we rely on puppet for that?
             resource[:ensure] = '0.0.7,5.11-0.151006:20131230T130000Z'
             allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
@@ -277,6 +279,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
           it "should install specific version(2)" do
             resource[:ensure] = '0.0.8'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
@@ -290,6 +293,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
           it "should downgrade to specific version" do
             resource[:ensure] = '0.0.7'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
             allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
@@ -301,6 +305,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
           it "should install any if version is not specified" do
             resource[:ensure] = :present
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
@@ -312,6 +317,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
 
           it "should install if no version was previously installed, and a specific version was requested" do
             resource[:ensure] = '0.0.7'
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
             expect(Puppet::Util::Execution).to receive(:execute)
@@ -325,6 +331,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             resource[:ensure] = '1.0-0.151006'
             is = :absent
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
@@ -340,6 +347,7 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             resource[:ensure] = '1.0-0.151006'
             is = '1.0,5.11-0.151006:20140219T191204Z'
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             expect(provider).to receive(:unhold).with(no_args)
@@ -398,12 +406,16 @@ describe Puppet::Type.type(:package).provider(:pkg) do
       it "should support current pkg version" do
         expect(described_class).to receive(:pkg).with(:version).and_return('630e1ffc7a19')
         expect(described_class).to receive(:pkg).with([:uninstall, resource[:name]])
+        expect(provider).to receive(:properties).and_return({:hold => false})
+
         provider.uninstall
       end
 
       it "should support original pkg commands" do
         expect(described_class).to receive(:pkg).with(:version).and_return('052adf36c3f4')
         expect(described_class).to receive(:pkg).with([:uninstall, '-r', resource[:name]])
+        expect(provider).to receive(:properties).and_return({:hold => false})
+
         provider.uninstall
       end
     end

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

@@ -45,7 +45,7 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
     it "should call hdiutil to mount and eject the disk image" do
       allow(Dir).to receive(:entries).and_return([])
       expect(provider.class).to receive(:hdiutil).with("eject", fake_mountpoint).and_return(0)
-      expect(provider.class).to receive(:hdiutil).with("mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", '/tmp/foo').and_return('a plist')
+      expect(provider.class).to receive(:hdiutil).with("mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", '/tmp/foo').and_return('a plist')
       expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
       provider.install
     end

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

@@ -110,6 +110,30 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
       end
       resource.provider.install
     end
+
+    it "should call pkg with the specified install options string" do
+      resource = Puppet::Type.type(:package).new(
+        :name            => 'curl',
+        :provider        => :pkgng,
+        :install_options => ['--foo', '--bar']
+      )
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('--foo', '--bar')
+      end
+      resource.provider.install
+    end
+
+    it "should call pkg with the specified install options hash" do
+      resource = Puppet::Type.type(:package).new(
+        :name            => 'curl',
+        :provider        => :pkgng,
+        :install_options => ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
+      )
+      expect(resource.provider).to receive(:pkg) do |arg|
+        expect(arg).to include('--foo', '--bar=baz', '--baz=foo')
+      end
+      resource.provider.install
+    end
   end
 
   context "#prefetch" do
@@ -169,6 +193,18 @@ describe Puppet::Type.type(:package).provider(:pkgng) do
       bash_comp_latest_version = described_class.get_latest_version('shells/bash-completion', version_list)
       expect(bash_comp_latest_version).to eq('2.1_3')
     end
+
+    it "should return nil when the package is orphaned" do
+      version_list = File.read(my_fixture('pkg.version'))
+      orphan_latest_version = described_class.get_latest_version('sysutils/orphan', version_list)
+      expect(orphan_latest_version).to be_nil
+    end
+
+    it "should return nil when the package is broken" do
+      version_list = File.read(my_fixture('pkg.version'))
+      broken_latest_version = described_class.get_latest_version('sysutils/broken', version_list)
+      expect(broken_latest_version).to be_nil
+    end
   end
 
   describe "confine" do

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

@@ -42,13 +42,13 @@ describe Puppet::Type.type(:package).provider(:portage) do
     allow(@unslotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
     allow(@unslotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
     @slotted_provider = described_class.new(@slotted_resource)
-    allow(@slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>":2.1", :pfx=>nil, :sfx=>nil})
+    allow(@slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>"2.1", :pfx=>nil, :sfx=>nil})
     allow(@slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
     @versioned_provider = described_class.new(@versioned_resource)
     allow(@versioned_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
     allow(@versioned_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
     @versioned_slotted_provider = described_class.new(@versioned_slotted_resource)
-    allow(@versioned_slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>":1.9", :pfx=>"=", :sfx=>nil})
+    allow(@versioned_slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>"1.9", :pfx=>"=", :sfx=>nil})
     allow(@versioned_slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
     @set_provider = described_class.new(@set_resource)
     allow(@set_provider).to receive(:qatom).and_return({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
@@ -166,7 +166,7 @@ describe Puppet::Type.type(:package).provider(:portage) do
   end
 
   it "can extract the slot from the package name" do
-    expect(@slotted_provider.qatom[:slot]).to eq(':2.1')
+    expect(@slotted_provider.qatom[:slot]).to eq('2.1')
   end
 
   it "returns nil for as the slot when no slot is specified" do
@@ -182,7 +182,7 @@ describe Puppet::Type.type(:package).provider(:portage) do
     expect(@versioned_slotted_provider.qatom[:category]).to eq('dev-lang')
     expect(@versioned_slotted_provider.qatom[:pn]).to eq('ruby')
     expect(@versioned_slotted_provider.qatom[:pv]).to eq('1.9.3')
-    expect(@versioned_slotted_provider.qatom[:slot]).to eq(':1.9')
+    expect(@versioned_slotted_provider.qatom[:slot]).to eq('1.9')
   end
 
   it "can handle search output with slots for unslotted packages" do

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

@@ -20,7 +20,10 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
     let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
   end
 
-  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
+  custom_environment = {"HOME"=>ENV["HOME"]}
+  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
+
+  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => custom_environment} }
 
   before :each do
     resource.provider = provider

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

@@ -54,6 +54,87 @@ describe Puppet::Type.type(:package).provider(:yum) do
         provider.install
       end
     end
+
+    describe 'with install_options' do
+      it 'can parse disable-repo with array of strings' do
+          resource[:install_options] = ['--disable-repo=dev*', '--disable-repo=prod*']
+          expect(provider).to receive(:execute) do | arr|
+            expect(arr[-3]).to eq(["--disable-repo=dev*", "--disable-repo=prod*"])
+          end
+          provider.install
+      end
+
+      it 'can parse disable-repo with array of hashes' do
+        resource[:install_options] = [{'--disable-repo' => 'dev*'}, {'--disable-repo' => 'prod*'}]
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq(["--disable-repo=dev*", "--disable-repo=prod*"])
+        end
+        provider.install
+      end
+
+      it 'can parse enable-repo with array of strings' do
+          resource[:install_options] = ['--enable-repo=dev*', '--enable-repo=prod*']
+          expect(provider).to receive(:execute) do | arr|
+            expect(arr[-3]).to eq(["--enable-repo=dev*", "--enable-repo=prod*"])
+          end
+          provider.install
+      end
+
+      it 'can parse enable-repo with array of hashes' do
+        resource[:install_options] = [{'--enable-repo' => 'dev*'}, {'--disable-repo' => 'prod*'}]
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq(["--enable-repo=dev*", "--disable-repo=prod*"])
+        end
+        provider.install
+      end
+
+      it 'can parse enable-repo with single hash' do
+        resource[:install_options] = [{'--enable-repo' => 'dev*','--disable-repo' => 'prod*'}]
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq(["--disable-repo=prod*", "--enable-repo=dev*"])
+        end
+        provider.install
+      end
+
+      it 'can parse enable-repo with empty array' do
+        resource[:install_options] = []
+        expect(provider).to receive(:execute) do | arr|
+          expect(arr[-3]).to eq([])
+        end
+        provider.install
+      end
+    end
+  end
+
+  context "latest" do
+    let(:name) { 'baz' }
+
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name => name,
+        :provider => 'yum',
+      )
+    end
+
+    let(:provider) do
+      provider = described_class.new
+      provider.resource = resource
+      provider
+    end
+
+    before {
+      allow(described_class).to receive(:command).with(:cmd).and_return("/usr/bin/yum")
+      Puppet[:log_level] = 'debug'
+    }
+
+    it "should print a debug message with the current version if newer package is not available" do
+      expect(provider).to receive(:query).and_return({:ensure => "1.2.3"})
+      expect(described_class).to receive(:latest_package_version).and_return(nil)
+      resource[:ensure] = :present
+
+      provider.latest
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Yum didn't find updates, current version (1.2.3) is the latest"))
+    end
   end
 
   context "parsing the output of check-update" do
@@ -144,5 +225,14 @@ describe Puppet::Type.type(:package).provider(:yum) do
         expect(output).not_to include("Random plugin")
       end
     end
+
+    context "with subscription manager enabled " do
+      let(:check_update) { File.read(my_fixture("yum-check-update-subscription-manager.txt")) }
+      let(:output) { described_class.parse_updates(check_update) }
+
+      it "parses correctly formatted entries" do
+        expect(output['curl.x86_64']).to eq([{:name => 'curl', :epoch => '0', :version => '7.32.0', :release => '10.fc20', :arch => 'x86_64'}])
+      end
+    end
   end
 end