puppet 6.12.0-universal-darwin → 6.17.0-universal-darwin

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

@@ -72,6 +72,11 @@ describe Puppet::Type.type(:package).provider(:portage) do
     expect(described_class).to be_reinstallable
   end
 
+  it "should be the default provider on :osfamily => Gentoo" do
+    expect(Facter).to receive(:value).with(:osfamily).and_return("Gentoo")
+    expect(described_class.default?).to be_truthy
+  end
+
   it 'should support string install options' do
     expect(@provider).to receive(:emerge).with('--foo', '--bar', @resource[:name])
 

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

@@ -67,6 +67,14 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
       expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
       provider.uninstall
     end
+
+    it 'should invalidate the rubygems cache' do
+      gem_source = double('gem_source')
+      allow(Puppet::Util::Autoload).to receive(:gem_source).and_return(gem_source)
+      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource}).and_return('')
+      expect(gem_source).to receive(:clear_paths)
+      provider.uninstall
+    end
   end
 
   context 'calculated specificity' do

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

@@ -552,218 +552,6 @@ describe Puppet::Type.type(:package).provider(:rpm) do
     end
   end
 
-  describe 'version comparison' do
-    # test cases munged directly from rpm's own
-    # tests/rpmvercmp.at
-    it { expect(provider.rpmvercmp("1.0", "1.0")).to eq(0) }
-    it { expect(provider.rpmvercmp("1.0", "2.0")).to eq(-1) }
-    it { expect(provider.rpmvercmp("2.0", "1.0")).to eq(1) }
-    it { expect(provider.rpmvercmp("2.0.1", "2.0.1")).to eq(0) }
-    it { expect(provider.rpmvercmp("2.0", "2.0.1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("2.0.1", "2.0")).to eq(1) }
-    it { expect(provider.rpmvercmp("2.0.1a", "2.0.1a")).to eq(0) }
-    it { expect(provider.rpmvercmp("2.0.1a", "2.0.1")).to eq(1) }
-    it { expect(provider.rpmvercmp("2.0.1", "2.0.1a")).to eq(-1) }
-    it { expect(provider.rpmvercmp("5.5p1", "5.5p1")).to eq(0) }
-    it { expect(provider.rpmvercmp("5.5p1", "5.5p2")).to eq(-1) }
-    it { expect(provider.rpmvercmp("5.5p2", "5.5p1")).to eq(1) }
-    it { expect(provider.rpmvercmp("5.5p10", "5.5p10")).to eq(0) }
-    it { expect(provider.rpmvercmp("5.5p1", "5.5p10")).to eq(-1) }
-    it { expect(provider.rpmvercmp("5.5p10", "5.5p1")).to eq(1) }
-    it { expect(provider.rpmvercmp("10xyz", "10.1xyz")).to eq(-1) }
-    it { expect(provider.rpmvercmp("10.1xyz", "10xyz")).to eq(1) }
-    it { expect(provider.rpmvercmp("xyz10", "xyz10")).to eq(0) }
-    it { expect(provider.rpmvercmp("xyz10", "xyz10.1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("xyz10.1", "xyz10")).to eq(1) }
-    it { expect(provider.rpmvercmp("xyz.4", "xyz.4")).to eq(0) }
-    it { expect(provider.rpmvercmp("xyz.4", "8")).to eq(-1) }
-    it { expect(provider.rpmvercmp("8", "xyz.4")).to eq(1) }
-    it { expect(provider.rpmvercmp("xyz.4", "2")).to eq(-1) }
-    it { expect(provider.rpmvercmp("2", "xyz.4")).to eq(1) }
-    it { expect(provider.rpmvercmp("5.5p2", "5.6p1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("5.6p1", "5.5p2")).to eq(1) }
-    it { expect(provider.rpmvercmp("5.6p1", "6.5p1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("6.5p1", "5.6p1")).to eq(1) }
-    it { expect(provider.rpmvercmp("6.0.rc1", "6.0")).to eq(1) }
-    it { expect(provider.rpmvercmp("6.0", "6.0.rc1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("10b2", "10a1")).to eq(1) }
-    it { expect(provider.rpmvercmp("10a2", "10b2")).to eq(-1) }
-    it { expect(provider.rpmvercmp("1.0aa", "1.0aa")).to eq(0) }
-    it { expect(provider.rpmvercmp("1.0a", "1.0aa")).to eq(-1) }
-    it { expect(provider.rpmvercmp("1.0aa", "1.0a")).to eq(1) }
-    it { expect(provider.rpmvercmp("10.0001", "10.0001")).to eq(0) }
-    it { expect(provider.rpmvercmp("10.0001", "10.1")).to eq(0) }
-    it { expect(provider.rpmvercmp("10.1", "10.0001")).to eq(0) }
-    it { expect(provider.rpmvercmp("10.0001", "10.0039")).to eq(-1) }
-    it { expect(provider.rpmvercmp("10.0039", "10.0001")).to eq(1) }
-    it { expect(provider.rpmvercmp("4.999.9", "5.0")).to eq(-1) }
-    it { expect(provider.rpmvercmp("5.0", "4.999.9")).to eq(1) }
-    it { expect(provider.rpmvercmp("20101121", "20101121")).to eq(0) }
-    it { expect(provider.rpmvercmp("20101121", "20101122")).to eq(-1) }
-    it { expect(provider.rpmvercmp("20101122", "20101121")).to eq(1) }
-    it { expect(provider.rpmvercmp("2_0", "2_0")).to eq(0) }
-    it { expect(provider.rpmvercmp("2.0", "2_0")).to eq(0) }
-    it { expect(provider.rpmvercmp("2_0", "2.0")).to eq(0) }
-    it { expect(provider.rpmvercmp("a", "a")).to eq(0) }
-    it { expect(provider.rpmvercmp("a+", "a+")).to eq(0) }
-    it { expect(provider.rpmvercmp("a+", "a_")).to eq(0) }
-    it { expect(provider.rpmvercmp("a_", "a+")).to eq(0) }
-    it { expect(provider.rpmvercmp("+a", "+a")).to eq(0) }
-    it { expect(provider.rpmvercmp("+a", "_a")).to eq(0) }
-    it { expect(provider.rpmvercmp("_a", "+a")).to eq(0) }
-    it { expect(provider.rpmvercmp("+_", "+_")).to eq(0) }
-    it { expect(provider.rpmvercmp("_+", "+_")).to eq(0) }
-    it { expect(provider.rpmvercmp("_+", "_+")).to eq(0) }
-    it { expect(provider.rpmvercmp("+", "_")).to eq(0) }
-    it { expect(provider.rpmvercmp("_", "+")).to eq(0) }
-    it { expect(provider.rpmvercmp("1.0~rc1", "1.0~rc1")).to eq(0) }
-    it { expect(provider.rpmvercmp("1.0~rc1", "1.0")).to eq(-1) }
-    it { expect(provider.rpmvercmp("1.0", "1.0~rc1")).to eq(1) }
-    it { expect(provider.rpmvercmp("1.0~rc1", "1.0~rc2")).to eq(-1) }
-    it { expect(provider.rpmvercmp("1.0~rc2", "1.0~rc1")).to eq(1) }
-    it { expect(provider.rpmvercmp("1.0~rc1~git123", "1.0~rc1~git123")).to eq(0) }
-    it { expect(provider.rpmvercmp("1.0~rc1~git123", "1.0~rc1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("1.0~rc1", "1.0~rc1~git123")).to eq(1) }
-    it { expect(provider.rpmvercmp("1.0~rc1", "1.0arc1")).to eq(-1) }
-    it { expect(provider.rpmvercmp("", "~")).to eq(1) }
-    it { expect(provider.rpmvercmp("~", "~~")).to eq(1) }
-    it { expect(provider.rpmvercmp("~", "~+~")).to eq(1) }
-    it { expect(provider.rpmvercmp("~", "~a")).to eq(-1) }
-
-    # non-upstream test cases
-    it { expect(provider.rpmvercmp("405", "406")).to eq(-1) }
-    it { expect(provider.rpmvercmp("1", "0")).to eq(1) }
-  end
-
-  describe 'package evr parsing' do
-    it 'should parse full simple evr' do
-      v = provider.rpm_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.rpm_parse_evr('1.2.3')
-      expect(v[:epoch]).to eq(nil)
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq(nil)
-    end
-
-    it 'should parse version-release' do
-      v = provider.rpm_parse_evr('1.2.3-4.5.el6')
-      expect(v[:epoch]).to eq(nil)
-      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.rpm_parse_evr('1.2.3-4.1234aefd')
-      expect(v[:epoch]).to eq(nil)
-      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.rpm_parse_evr('12345')
-      expect(v[:epoch]).to eq(nil)
-      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.rpm_parse_evr('foo0:1.2.3-4')
-      expect(v[:epoch]).to eq(nil)
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq('4')
-    end
-
-    it 'should parse revisions with text' do
-      v = provider.rpm_parse_evr('1.2.3-SNAPSHOT20140107')
-      expect(v[:epoch]).to eq(nil)
-      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.rpm_parse_evr('2.2-SNAPSHOT20121119105647')
-      expect(v[:epoch]).to eq(nil)
-      expect(v[:version]).to eq('2.2')
-      expect(v[:release]).to eq('SNAPSHOT20121119105647')
-    end
-  end
-
-  describe 'rpm evr comparison' do
-    # currently passing tests
-    it 'should evaluate identical version-release as equal' do
-      v = provider.rpm_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.rpm_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.rpm_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.rpm_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.rpm_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.rpm_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.rpm_compareEVR({:epoch => '0', :version => '2.2', :release => '405'},
-                               {:epoch => '0', :version => '2.2', :release => '406'})).to eq(-1)
-    end
-  end
-
-  describe '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
-      allow(provider).to receive(:rpmvercmp).and_return(0)
-      expect(provider).to receive(:rpmvercmp).with('s1', 's2')
-      provider.compare_values('s1', 's2')
-    end
-  end
-
-
   describe 'insync?' do
     context 'for multiple versions' do
       let(:is) { '1:1.2.3.4-5.el4; 1:5.6.7.8-5.el4' }

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

@@ -3,6 +3,17 @@ require 'spec_helper'
 describe Puppet::Type.type(:package).provider(:yum) do
   include PuppetSpec::Fixtures
 
+  let(:resource_name) { 'myresource' }
+  let(:resource) do
+    Puppet::Type.type(:package).new(
+      :name     => resource_name,
+      :ensure   => :installed,
+      :provider => 'yum'
+    )
+  end
+
+  let(:provider) { Puppet::Type.type(:package).provider(:yum).new(resource) }
+
   it_behaves_like 'RHEL package provider', described_class, 'yum'
 
   it "should have lower specificity" do
@@ -95,6 +106,56 @@ 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 "parsing the output of check-update" do
@@ -185,5 +246,236 @@ 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
+
+  describe 'insync?' do
+    context 'when version is not a valid RPM version' do
+      let(:is) { '>===a:123' }
+
+      before do
+        resource[:ensure] = is
+      end
+
+      it 'logs a debug message' do
+        expect(Puppet).to receive(:debug).with("Cannot parse #{is} as a RPM version range")
+        provider.insync?(is)
+      end
+    end
+
+    context 'with valid semantic versions' do
+      let(:is) { '1:1.2.3.4-5.el4' }
+
+      it 'returns true if the current version matches the given semantic version' do
+        resource[:ensure] = is
+        expect(provider).to be_insync(is)
+      end
+
+      it 'returns false if the current version does not match the given semantic version' do
+        resource[:ensure] = '999r'
+        expect(provider).not_to be_insync(is)
+      end
+
+      it 'no debug logs if the current version matches the given semantic version' do
+        resource[:ensure] = is
+        expect(Puppet).not_to receive(:debug)
+        provider.insync?(is)
+      end
+
+      it 'returns true if current version matches the greater or equal semantic version in ensure' do
+        resource[:ensure] = '<=1:1.2.3.4-5.el4'
+        expect(provider).to be_insync(is)
+      end
+
+      it 'returns true if current version matches the lesser semantic version in ensure' do
+        resource[:ensure] = '>1:1.0.0'
+        expect(provider).to be_insync(is)
+      end
+
+      it 'returns true if current version matches two semantic conditions' do
+        resource[:ensure] = '>1:1.1.3.4-5.el4 <1:1.3.3.6-5.el4'
+        expect(provider).to be_insync(is)
+      end
+
+      it 'returns false if current version does not match matches two semantic conditions' do
+        resource[:ensure] = '<1:1.1.3.4-5.el4 <1:1.3.3.6-5.el4'
+        expect(provider).not_to be_insync(is)
+      end
+    end
+  end
+
+  describe 'install' do
+    before do
+      resource[:ensure] = ensure_value
+      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('7')
+      allow(described_class).to receive(:command).with(:cmd).and_return('/usr/bin/yum')
+      allow(provider).to receive(:query).twice.and_return(nil, ensure: '18.3.2')
+      allow(provider).to receive(:insync?).with('18.3.2').and_return(true)
+    end
+
+    context 'with version range' do
+      before do
+        allow(provider).to receive(:available_versions).and_return(available_versions)
+      end
+
+      context 'without epoch' do
+        let(:ensure_value) { '>18.1 <19' }
+        let(:available_versions) { ['17.5.2', '18.0', 'a:23', '18.3', '18.3.2', '19.0', '3:18.4'] }
+
+        it 'selects best_version' do
+          expect(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'myresource-18.3.2']
+          )
+          provider.install
+        end
+
+        context 'when comparing with available packages that do not have epoch' do
+          let(:ensure_value) { '>18' }
+          let(:available_versions) { ['18.3.3', '3:18.3.2'] }
+
+          it 'treats no epoch as zero' do
+            expect(provider).to receive(:execute).with(
+              ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'myresource-18.3.2']
+              )
+            provider.install
+          end
+        end
+      end
+
+      context 'with epoch' do
+        let(:ensure_value) { '>18.1 <3:19' }
+        let(:available_versions) { ['3:17.5.2', '3:18.0', 'a:23', '18.3.3', '3:18.3.2', '3:19.0', '19.1'] }
+
+        it 'selects best_version and removes epoch' do
+          expect(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, 'myresource-18.3.2']
+          )
+          provider.install
+        end
+      end
+
+      context 'when no suitable version in range' do
+        let(:ensure_value) { '>18.1 <19' }
+        let(:available_versions) { ['3:17.5.2', '3:18.0', 'a:23' '18.3', '3:18.3.2', '3:19.0', '19.1'] }
+
+        it 'uses requested version' do
+          expect(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "myresource->18.1 <19"]
+          )
+          provider.install
+        end
+
+        it 'logs a debug message' do
+          allow(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "myresource->18.1 <19"]
+          )
+
+          expect(Puppet).to receive(:debug).with(
+            "No available version for package myresource is included in range >18.1 <19"
+          )
+          provider.install
+        end
+      end
+    end
+
+    context 'with fix version' do
+      let(:ensure_value) { '1:18.12' }
+
+      it 'passes the version to yum command' do
+        expect(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "myresource-1:18.12"]
+          )
+          provider.install
+      end
+    end
+
+    context 'when upgrading' do
+      let(:ensure_value) { '>18.1 <19' }
+      let(:available_versions) { ['17.5.2', '18.0', 'a:23' '18.3', '18.3.2', '19.0', '3:18.4'] }
+
+      before do
+        allow(provider).to receive(:available_versions).and_return(available_versions)
+        allow(provider).to receive(:query).twice
+          .and_return({ ensure: '17.0' }, { ensure: '18.3.2' })
+      end
+
+      it 'adds update flag to install command' do
+        expect(provider).to receive(:execute).with(
+          ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', 'update', 'myresource-18.3.2']
+        )
+        provider.install
+      end
+    end
+
+    context 'when dowgrading' do
+      let(:ensure_value) { '>18.1 <19' }
+      let(:available_versions) { ['17.5.2', '18.0', 'a:23' '18.3', '18.3.2', '19.0', '3:18.4'] }
+
+      before do
+        allow(provider).to receive(:available_versions).and_return(available_versions)
+        allow(provider).to receive(:query).twice
+          .and_return({ ensure: '19.0' }, { ensure: '18.3.2' })
+      end
+
+      it 'adds downgrade flag to install command' do
+        expect(provider).to receive(:execute).with(
+          ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :downgrade, 'myresource-18.3.2']
+        )
+        provider.install
+      end
+    end
+
+    context 'on failure' do
+      let(:ensure_value) { '20' }
+
+      context 'when execute command fails' do
+        before do
+          allow(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "myresource-20"]
+          ).and_return('No package myresource-20 available.')
+        end
+
+        it 'raises Puppet::Error' do
+          expect { provider.install }.to \
+            raise_error(Puppet::Error, 'Could not find package myresource-20')
+        end
+      end
+
+      context 'when package is not found' do
+        before do
+          allow(provider).to receive(:query)
+          allow(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "myresource-20"]
+          )
+        end
+
+        it 'raises Puppet::Error' do
+          expect { provider.install }.to \
+            raise_error(Puppet::Error, 'Could not find package myresource')
+        end
+      end
+
+      context 'when package is not installed' do
+        before do
+          allow(provider).to receive(:execute).with(
+            ['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "myresource-20"]
+          )
+          allow(provider).to receive(:insync?).and_return(false)
+        end
+
+        it 'raises Puppet::Error' do
+          expect { provider.install }.to \
+            raise_error(Puppet::Error, 'Failed to update to version 20, got version 18.3.2 instead')
+        end
+      end
+    end
   end
 end