puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,27 +1,30 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/package/windows/package'
 
 describe Puppet::Provider::Package::Windows::Package do
+  subject { described_class }
+
   let(:hklm) { 'HKEY_LOCAL_MACHINE' }
   let(:hkcu) { 'HKEY_CURRENT_USER' }
   let(:path) { 'Software\Microsoft\Windows\CurrentVersion\Uninstall' }
-  let(:key)  { double('key', :name => "#{hklm}\\#{path}\\Google") }
-  let(:package)  { double('package') }
+  let(:key)  { mock('key', :name => "#{hklm}\\#{path}\\Google") }
+  let(:package)  { mock('package') }
 
   context '::each' do
     it 'should generate an empty enumeration' do
-      expect(described_class).to receive(:with_key)
+      subject.expects(:with_key)
 
-      expect(described_class.to_a).to be_empty
+      expect(subject.to_a).to be_empty
     end
 
     it 'should yield each package it finds' do
-      expect(described_class).to receive(:with_key).and_yield(key, {})
+      subject.expects(:with_key).yields(key, {})
 
-      expect(Puppet::Provider::Package::Windows::MsiPackage).to receive(:from_registry).with('Google', {}).and_return(package)
+      Puppet::Provider::Package::Windows::MsiPackage.expects(:from_registry).with('Google', {}).returns(package)
 
       yielded = nil
-      described_class.each do |pkg|
+      subject.each do |pkg|
         yielded = pkg
       end
 
@@ -29,33 +32,35 @@ describe Puppet::Provider::Package::Windows::Package do
     end
   end
 
-  context '::with_key', :if => Puppet.features.microsoft_windows? do
+  context '::with_key', :if => Puppet::Util::Platform.windows? do
     it 'should search HKLM (64 & 32) and HKCU (64 & 32)' do
-      expect(described_class).to receive(:open).with(hklm, path, described_class::KEY64 | described_class::KEY_READ).ordered
-      expect(described_class).to receive(:open).with(hklm, path, described_class::KEY32 | described_class::KEY_READ).ordered
-      expect(described_class).to receive(:open).with(hkcu, path, described_class::KEY64 | described_class::KEY_READ).ordered
-      expect(described_class).to receive(:open).with(hkcu, path, described_class::KEY32 | described_class::KEY_READ).ordered
+      seq = sequence('reg')
+
+      subject.expects(:open).with(hklm, path, subject::KEY64 | subject::KEY_READ).in_sequence(seq)
+      subject.expects(:open).with(hklm, path, subject::KEY32 | subject::KEY_READ).in_sequence(seq)
+      subject.expects(:open).with(hkcu, path, subject::KEY64 | subject::KEY_READ).in_sequence(seq)
+      subject.expects(:open).with(hkcu, path, subject::KEY32 | subject::KEY_READ).in_sequence(seq)
 
-      described_class.with_key { |key, values| }
+      subject.with_key { |key, values| }
     end
 
     it 'should ignore file not found exceptions' do
       ex = Puppet::Util::Windows::Error.new('Failed to open registry key', Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND)
 
       # make sure we don't stop after the first exception
-      expect(described_class).to receive(:open).exactly(4).times().and_raise(ex)
+      subject.expects(:open).times(4).raises(ex)
 
       keys = []
-      described_class.with_key { |key, values| keys << key }
+      subject.with_key { |key, values| keys << key }
       expect(keys).to be_empty
     end
 
     it 'should raise other types of exceptions' do
       ex = Puppet::Util::Windows::Error.new('Failed to open registry key', Puppet::Util::Windows::Error::ERROR_ACCESS_DENIED)
-      expect(described_class).to receive(:open).and_raise(ex)
+      subject.expects(:open).raises(ex)
 
       expect {
-        described_class.with_key{ |key, values| }
+        subject.with_key{ |key, values| }
       }.to raise_error do |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
         expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
@@ -66,7 +71,7 @@ describe Puppet::Provider::Package::Windows::Package do
   context '::installer_class' do
     it 'should require the source parameter' do
       expect {
-        described_class.installer_class({})
+        subject.installer_class({})
       }.to raise_error(Puppet::Error, /The source parameter is required when using the Windows provider./)
     end
 
@@ -74,20 +79,20 @@ describe Puppet::Provider::Package::Windows::Package do
       let (:klass) { Puppet::Provider::Package::Windows::MsiPackage }
 
       it 'should accept source ending in .msi' do
-        expect(described_class.installer_class({:source => 'foo.msi'})).to eq(klass)
+        expect(subject.installer_class({:source => 'foo.msi'})).to eq(klass)
       end
 
       it 'should accept quoted source ending in .msi' do
-        expect(described_class.installer_class({:source => '"foo.msi"'})).to eq(klass)
+        expect(subject.installer_class({:source => '"foo.msi"'})).to eq(klass)
       end
 
       it 'should accept source case insensitively' do
-        expect(described_class.installer_class({:source => '"foo.MSI"'})).to eq(klass)
+        expect(subject.installer_class({:source => '"foo.MSI"'})).to eq(klass)
       end
 
       it 'should reject source containing msi in the name' do
         expect {
-          described_class.installer_class({:source => 'mymsi.txt'})
+          subject.installer_class({:source => 'mymsi.txt'})
         }.to raise_error(Puppet::Error, /Don't know how to install 'mymsi.txt'/)
       end
     end
@@ -95,7 +100,7 @@ describe Puppet::Provider::Package::Windows::Package do
     context 'Unknown' do
       it 'should reject packages it does not know about' do
         expect {
-          described_class.installer_class({:source => 'basram'})
+          subject.installer_class({:source => 'basram'})
         }.to raise_error(Puppet::Error, /Don't know how to install 'basram'/)
       end
     end
@@ -103,76 +108,76 @@ describe Puppet::Provider::Package::Windows::Package do
 
   context '::munge' do
     it 'should shell quote strings with spaces and fix forward slashes' do
-      expect(described_class.munge('c:/windows/the thing')).to eq('"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
-      expect(described_class.munge('c:\windows\thething')).to eq('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
-      expect(described_class.replace_forward_slashes('c:/windows/thing/stuff')).to eq('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
-      expect(described_class.quote('foo bar')).to eq('"foo bar"')
+      expect(subject.quote('foo bar')).to eq('"foo bar"')
     end
 
     it 'should shell quote strings with spaces and quotes' do
-      expect(described_class.quote('"foo bar" baz')).to eq('"\"foo bar\" baz"')
+      expect(subject.quote('"foo bar" baz')).to eq('"\"foo bar\" baz"')
     end
 
     it 'should not shell quote strings without spaces' do
-      expect(described_class.quote('"foobar"')).to eq('"foobar"')
+      expect(subject.quote('"foobar"')).to eq('"foobar"')
     end
   end
 
   context '::get_display_name' do
     it 'should return nil if values is nil' do
-      expect(described_class.get_display_name(nil)).to be_nil
+      expect(subject.get_display_name(nil)).to be_nil
     end
 
     it 'should return empty if values is empty' do
       reg_values =  {}
-      expect(described_class.get_display_name(reg_values)).to eq('')
+      expect(subject.get_display_name(reg_values)).to eq('')
     end
 
     it 'should return DisplayName when available' do
       reg_values =  { 'DisplayName' => 'Google' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google')
+      expect(subject.get_display_name(reg_values)).to eq('Google')
     end
 
     it 'should return DisplayName when available, even when QuietDisplayName is also available' do
       reg_values =  { 'DisplayName' => 'Google', 'QuietDisplayName' => 'Google Quiet' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google')
+      expect(subject.get_display_name(reg_values)).to eq('Google')
     end
 
     it 'should return QuietDisplayName when available if DisplayName is empty' do
       reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'Google Quiet' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google Quiet')
+      expect(subject.get_display_name(reg_values)).to eq('Google Quiet')
     end
 
     it 'should return QuietDisplayName when DisplayName is not available' do
       reg_values =  { 'QuietDisplayName' =>'Google Quiet' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google Quiet')
+      expect(subject.get_display_name(reg_values)).to eq('Google Quiet')
     end
 
     it 'should return empty when DisplayName is empty and QuietDisplay name is not available' do
       reg_values =  { 'DisplayName' => '' }
-      expect(described_class.get_display_name(reg_values)).to eq('')
+      expect(subject.get_display_name(reg_values)).to eq('')
     end
 
     it 'should return empty when DisplayName is empty and QuietDisplay name is empty' do
       reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'' }
-      expect(described_class.get_display_name(reg_values)).to eq('')
+      expect(subject.get_display_name(reg_values)).to eq('')
     end
   end
 
   it 'should implement instance methods' do
-    pkg = described_class.new('orca', '5.0')
+    pkg = subject.new('orca', '5.0')
 
     expect(pkg.name).to eq('orca')
     expect(pkg.version).to eq('5.0')

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

@@ -1,24 +1,20 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.microsoft_windows? do
-  let(:name)        { 'mysql-5.1.58-win-x64' }
-  let(:source)      { 'E:\Rando\Directory\mysql-5.1.58-win-x64.msi' }
-  let(:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :windows, :source => source) }
-  let(:provider)    { resource.provider }
-  let(:execute_options) do {:failonfail => false, :combine => true, :suppress_window => true} end
+describe Puppet::Type.type(:package).provider(:windows) do
+  let (:name)        { 'mysql-5.1.58-win-x64' }
+  let (:source)      { 'E:\mysql-5.1.58-win-x64.msi' }
+  let (:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :windows, :source => source) }
+  let (:provider)    { resource.provider }
+  let (:execute_options) do {:failonfail => false, :combine => true} end
 
-  before(:each) do
+  before :each do
     # make sure we never try to execute anything
-    @times_execute_called = 0
-    allow(provider).to receive(:execute) { @times_execute_called += 1}
-  end
-
-  after(:each) do
-    expect(@times_execute_called).to eq(0)
+    provider.expects(:execute).never
   end
 
   def expect_execute(command, status)
-    expect(provider).to receive(:execute).with(command, execute_options).and_return(Puppet::Util::Execution::ProcessOutput.new('',status))
+    provider.expects(:execute).with(command, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new('',status))
   end
 
   describe 'provider features' do
@@ -29,7 +25,7 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
     it { is_expected.to be_versionable }
   end
 
-  describe 'on Windows', :if => Puppet.features.microsoft_windows? do
+  describe 'on Windows', :if => Puppet::Util::Platform.windows? do
     it 'should be the default provider' do
       expect(Puppet::Type.type(:package).defaultprovider).to eq(subject.class)
     end
@@ -37,13 +33,13 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
   context '::instances' do
     it 'should return an array of provider instances' do
-      pkg1 = double('pkg1')
-      pkg2 = double('pkg2')
+      pkg1 = stub('pkg1')
+      pkg2 = stub('pkg2')
 
-      prov1 = double('prov1', :name => 'pkg1', :version => '1.0.0', :package => pkg1)
-      prov2 = double('prov2', :name => 'pkg2', :version => nil, :package => pkg2)
+      prov1 = stub('prov1', :name => 'pkg1', :version => '1.0.0', :package => pkg1)
+      prov2 = stub('prov2', :name => 'pkg2', :version => nil, :package => pkg2)
 
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:map).and_yield(prov1).and_yield(prov2).and_return([prov1, prov2])
+      Puppet::Provider::Package::Windows::Package.expects(:map).multiple_yields([prov1], [prov2]).returns([prov1, prov2])
 
       providers = provider.class.instances
       expect(providers.count).to eq(2)
@@ -57,7 +53,7 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
     end
 
     it 'should return an empty array if none found' do
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:map).and_return([])
+      Puppet::Provider::Package::Windows::Package.expects(:map).returns([])
 
       expect(provider.class.instances).to eq([])
     end
@@ -65,23 +61,23 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
   context '#query' do
     it 'should return the hash of the matched packaged' do
-      pkg = double(:name => 'pkg1', :version => nil)
-      expect(pkg).to receive(:match?).and_return(true)
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:find).and_yield(pkg)
+      pkg = mock(:name => 'pkg1', :version => nil)
+      pkg.expects(:match?).returns(true)
+      Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
       expect(provider.query).to eq({ :name => 'pkg1', :ensure => :installed, :provider => :windows })
     end
 
     it 'should include the version string when present' do
-      pkg = double(:name => 'pkg1', :version => '1.0.0')
-      expect(pkg).to receive(:match?).and_return(true)
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:find).and_yield(pkg)
+      pkg = mock(:name => 'pkg1', :version => '1.0.0')
+      pkg.expects(:match?).returns(true)
+      Puppet::Provider::Package::Windows::Package.expects(:find).yields(pkg)
 
       expect(provider.query).to eq({ :name => 'pkg1', :ensure => '1.0.0', :provider => :windows })
     end
 
     it 'should return nil if no package was found' do
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:find)
+      Puppet::Provider::Package::Windows::Package.expects(:find)
 
       expect(provider.query).to be_nil
     end
@@ -89,10 +85,10 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
   context '#install' do
     let(:command) { 'blarg.exe /S' }
-    let(:klass) { double('installer', :install_command => ['blarg.exe', '/S'] ) }
-    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => nil, :suppress_window => true} end
+    let(:klass) { mock('installer', :install_command => ['blarg.exe', '/S'] ) }
+
     before :each do
-      expect(Puppet::Provider::Package::Windows::Package).to receive(:installer_class).and_return(klass)
+      Puppet::Provider::Package::Windows::Package.expects(:installer_class).returns(klass)
     end
 
     it 'should join the install command and options' do
@@ -111,26 +107,26 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
     it 'should not warn if the package install succeeds' do
       expect_execute(command, 0)
-      expect(provider).not_to receive(:warning)
+      provider.expects(:warning).never
 
       provider.install
     end
 
     it 'should warn if reboot initiated' do
       expect_execute(command, 1641)
-      expect(provider).to receive(:warning).with('The package installed successfully and the system is rebooting now.')
+      provider.expects(:warning).with('The package installed successfully and the system is rebooting now.')
 
       provider.install
     end
 
     it 'should warn if reboot required' do
       expect_execute(command, 3010)
-      expect(provider).to receive(:warning).with('The package installed successfully, but the system must be rebooted.')
+      provider.expects(:warning).with('The package installed successfully, but the system must be rebooted.')
 
       provider.install
     end
 
-    it 'should fail otherwise', :if => Puppet.features.microsoft_windows? do
+    it 'should fail otherwise', :if => Puppet::Util::Platform.windows? do
       expect_execute(command, 5)
 
       expect do
@@ -140,22 +136,11 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
         expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
       end
     end
-
-    context 'With a real working dir' do
-      let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
-
-      it 'should not try to set the working directory' do
-        expect(Puppet::FileSystem).to receive(:exist?).with('E:\Rando\Directory').and_return(true)
-        expect_execute(command, 0)
-
-        provider.install
-      end
-    end
   end
 
   context '#uninstall' do
     let(:command) { 'unblarg.exe /Q' }
-    let(:package) { double('package', :uninstall_command => ['unblarg.exe', '/Q'] ) }
+    let(:package) { mock('package', :uninstall_command => ['unblarg.exe', '/Q'] ) }
 
     before :each do
       resource[:ensure] = :absent
@@ -177,26 +162,26 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
 
     it 'should not warn if the package install succeeds' do
       expect_execute(command, 0)
-      expect(provider).not_to receive(:warning)
+      provider.expects(:warning).never
 
       provider.uninstall
     end
 
     it 'should warn if reboot initiated' do
       expect_execute(command, 1641)
-      expect(provider).to receive(:warning).with('The package uninstalled successfully and the system is rebooting now.')
+      provider.expects(:warning).with('The package uninstalled successfully and the system is rebooting now.')
 
       provider.uninstall
     end
 
     it 'should warn if reboot required' do
       expect_execute(command, 3010)
-      expect(provider).to receive(:warning).with('The package uninstalled successfully, but the system must be rebooted.')
+      provider.expects(:warning).with('The package uninstalled successfully, but the system must be rebooted.')
 
       provider.uninstall
     end
 
-    it 'should fail otherwise', :if => Puppet.features.microsoft_windows? do
+    it 'should fail otherwise', :if => Puppet::Util::Platform.windows? do
       expect_execute(command, 5)
 
       expect do

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

@@ -1,9 +1,18 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:yum) do
+provider_class = Puppet::Type.type(:package).provider(:yum)
+
+describe provider_class do
   include PuppetSpec::Fixtures
+  it_behaves_like 'RHEL package provider', provider_class, 'yum'
 
-  it_behaves_like 'RHEL package provider', described_class, 'yum'
+  it "should have lower specificity" do
+    Facter.stubs(:value).with(:osfamily).returns(:redhat)
+    Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("22")
+    expect(provider_class.specificity).to be < 200
+  end
 
   describe "when supplied the source param" do
     let(:name) { 'baz' }
@@ -16,25 +25,18 @@ describe Puppet::Type.type(:package).provider(:yum) do
     end
 
     let(:provider) do
-      provider = described_class.new
+      provider = provider_class.new
       provider.resource = resource
       provider
     end
 
-    before { allow(described_class).to receive(:command).with(:cmd).and_return("/usr/bin/yum") }
-
-  describe 'provider features' do
-    it { is_expected.to be_versionable }
-    it { is_expected.to be_install_options }
-    it { is_expected.to be_virtual_packages }
-    it { is_expected.to be_install_only }
-  end
+    before { provider_class.stubs(:command).with(:cmd).returns("/usr/bin/yum") }
 
     context "when installing" do
       it "should use the supplied source as the explicit path to a package to install" do
         resource[:ensure] = :present
         resource[:source] = "/foo/bar/baz-1.1.0.rpm"
-        expect(provider).to receive(:execute) do |arr|
+        provider.expects(:execute).with do |arr|
           expect(arr[-2..-1]).to eq([:install, "/foo/bar/baz-1.1.0.rpm"])
         end
         provider.install
@@ -45,110 +47,27 @@ describe Puppet::Type.type(:package).provider(:yum) do
       it "should use the suppplied source as the explicit path to the package to update" do
         # The first query response informs yum provider that package 1.1.0 is
         # already installed, and the second that it's been upgraded
-        expect(provider).to receive(:query).twice.and_return({:ensure => "1.1.0"}, {:ensure => "1.2.0"})
+        provider.expects(:query).twice.returns({:ensure => "1.1.0"}, {:ensure => "1.2.0"})
         resource[:ensure] = "1.2.0"
         resource[:source] = "http://foo.repo.com/baz-1.2.0.rpm"
-        expect(provider).to receive(:execute) do |arr|
+        provider.expects(:execute).with do |arr|
           expect(arr[-2..-1]).to eq(['update', "http://foo.repo.com/baz-1.2.0.rpm"])
         end
         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
-    context "with no multiline entries" do
+  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'}])
@@ -158,81 +77,58 @@ describe Puppet::Type.type(:package).provider(:yum) do
         expect(output['java-1.8.0-openjdk.x86_64']).to eq([{:name => 'java-1.8.0-openjdk', :epoch => '1', :version => '1.8.0.131', :release => '2.b11.el7_3', :arch => 'x86_64'}])
       end
     end
-
-    context "with multiline entries" do
+    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
-
-    context "with obsoleted packages" do
+    describe "with obsoleted packages" do
       let(:check_update) { File.read(my_fixture("yum-check-update-obsoletes.txt")) }
       let(:output) { described_class.parse_updates(check_update) }
-
       it "ignores all entries including and after 'Obsoleting Packages'" do
         expect(output).not_to include("Obsoleting")
         expect(output).not_to include("NetworkManager-bluetooth.x86_64")
         expect(output).not_to include("1:1.0.0-14.git20150121.b4ea599c.el7")
       end
     end
-
-    context "with security notifications" do
+    describe "with security notifications" do
       let(:check_update) { File.read(my_fixture("yum-check-update-security.txt")) }
       let(:output) { described_class.parse_updates(check_update) }
-
       it "ignores all entries including and after 'Security'" do
         expect(output).not_to include("Security")
       end
-
       it "includes updates before 'Security'" do
         expect(output).to include("yum-plugin-fastestmirror.noarch")
       end
     end
-
-    context "with broken update notices" do
+    describe "with broken update notices" do
       let(:check_update) { File.read(my_fixture("yum-check-update-broken-notices.txt")) }
       let(:output) { described_class.parse_updates(check_update) }
-
       it "ignores all entries including and after 'Update'" do
         expect(output).not_to include("Update")
       end
-
       it "includes updates before 'Update'" do
         expect(output).to include("yum-plugin-fastestmirror.noarch")
       end
     end
-
-    context "with improper package names in output" do
+    describe "with improper package names in output" do
       it "raises an exception parsing package name" do
         expect {
           described_class.update_to_hash('badpackagename', '1')
         }.to raise_exception(Exception, /Failed to parse/)
       end
     end
-
-    context "with trailing plugin output" do
+    describe "with trailing plugin output" do
       let(:check_update) { File.read(my_fixture("yum-check-update-plugin-output.txt")) }
       let(:output) { described_class.parse_updates(check_update) }
-
       it "parses correctly formatted entries" do
         expect(output['bash']).to eq([{:name => 'bash', :epoch => '0', :version => '4.2.46', :release => '12.el7', :arch => 'x86_64'}])
       end
-
       it "ignores all mentions of plugin output" 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