puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

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

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:aix) do
-  before(:each) do
-    # Create a mock resource
-    @resource = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :installed, :source => 'mysource', :provider => :aix)
-
-    @provider = @resource.provider
-  end
-
-  [:install, :uninstall, :latest, :query, :update].each do |method|
-    it "should have a #{method} method" do
-      expect(@provider).to respond_to(method)
-    end
-  end
-
-  it "should uninstall a package" do
-    expect(@provider).to receive(:installp).with('-gu', 'mypackage')
-    expect(@provider.class).to receive(:pkglist).with({:pkgname => 'mypackage'}).and_return(nil)
-    @provider.uninstall
-  end
-
-  context "when installing" do
-    it "should install a package" do
-      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => :committed})
-      expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
-      @provider.install
-    end
-
-    it "should install a specific package version" do
-      allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
-      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => '1.2.3.4', :status => :committed})
-      expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
-      @provider.install
-    end
-
-    [:broken, :inconsistent].each do |state|
-      it "should fail if the installation resulted in a '#{state}' state" do
-        allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => state})
-        expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
-        expect { @provider.install }.to raise_error(Puppet::Error, "Package 'mypackage' is in a #{state} state and requires manual intervention")
-      end
-    end
-
-    it "should fail if the specified version is superseded" do
-      @resource[:ensure] = '1.2.3.3'
-      allow(@provider).to receive(:installp).and_return(<<-OUTPUT)
-+-----------------------------------------------------------------------------+
-                    Pre-installation Verification...
-+-----------------------------------------------------------------------------+
-Verifying selections...done
-Verifying requisites...done
-Results...
-
-WARNINGS
---------
-  Problems described in this section are not likely to be the source of any
-  immediate or serious failures, but further actions may be necessary or
-  desired.
-
-  Already Installed
-  -----------------
-  The number of selected filesets that are either already installed
-  or effectively installed through superseding filesets is 1.  See
-  the summaries at the end of this installation for details.
-
-  NOTE:  Base level filesets may be reinstalled using the "Force"
-  option (-F flag), or they may be removed, using the deinstall or
-  "Remove Software Products" facility (-u flag), and then reinstalled.
-
-  << End of Warning Section >>
-
-+-----------------------------------------------------------------------------+
-                   BUILDDATE Verification ...
-+-----------------------------------------------------------------------------+
-Verifying build dates...done
-FILESET STATISTICS
-------------------
-    1  Selected to be installed, of which:
-        1  Already installed (directly or via superseding filesets)
-  ----
-    0  Total to be installed
-
-
-Pre-installation Failure/Warning Summary
-----------------------------------------
-Name                      Level           Pre-installation Failure/Warning
--------------------------------------------------------------------------------
-mypackage                 1.2.3.3         Already superseded by 1.2.3.4
-      OUTPUT
-
-      expect { @provider.install }.to raise_error(Puppet::Error, "aix package provider is unable to downgrade packages")
-    end
-  end
-
-  context "when finding the latest version" do
-    it "should return the current version when no later version is present" do
-      allow(@provider).to receive(:latest_info).and_return(nil)
-      allow(@provider).to receive(:properties).and_return({ :ensure => "1.2.3.4" })
-      expect(@provider.latest).to eq("1.2.3.4")
-    end
-
-    it "should return the latest version of a package" do
-      allow(@provider).to receive(:latest_info).and_return({ :version => "1.2.3.5" })
-      expect(@provider.latest).to eq("1.2.3.5")
-    end
-
-    it "should prefetch the right values" do
-      allow(Process).to receive(:euid).and_return(0)
-      resource = Puppet::Type.type(:package).
-          new(:name => 'sudo.rte', :ensure => :latest,
-              :source => 'mysource', :provider => :aix)
-
-      allow(resource).to receive(:should).with(:ensure).and_return(:latest)
-      resource.should(:ensure)
-
-      allow(resource.provider.class).to receive(:execute).and_return(<<-END.chomp)
-sudo:sudo.rte:1.7.10.4::I:C:::::N:Configurable super-user privileges runtime::::0::
-sudo:sudo.rte:1.8.6.4::I:T:::::N:Configurable super-user privileges runtime::::0::
-END
-
-      resource.provider.class.prefetch('sudo.rte' => resource)
-      expect(resource.provider.latest).to eq('1.8.6.4')
-    end
-  end
-
-  it "update should install a package" do
-    expect(@provider).to receive(:install).with(false)
-    @provider.update
-  end
-
-  it "should prefetch when some packages lack sources" do
-    latest = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :latest, :source => 'mysource', :provider => :aix)
-    absent = Puppet::Type.type(:package).new(:name => 'otherpackage', :ensure => :absent, :provider => :aix)
-    allow(Process).to receive(:euid).and_return(0)
-    expect(described_class).to receive(:execute).and_return('mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n')
-    described_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
-  end
-
-  context "when querying instances" do
-    before(:each) do
-      allow(described_class).to receive(:execute).and_return(<<-END.chomp)
-sysmgt.cim.providers:sysmgt.cim.providers.metrics:2.12.1.1: : :B: :Metrics Providers for AIX OS: : : : : : :1:0:/:
-sysmgt.cim.providers:sysmgt.cim.providers.osbase:2.12.1.1: : :C: :Base Providers for AIX OS: : : : : : :1:0:/:
-openssl.base:openssl.base:1.0.2.1800: : :?: :Open Secure Socket Layer: : : : : : :0:0:/:
-END
-    end
-
-    it "should treat installed packages in broken and inconsistent state as absent" do
-      installed_packages = described_class.instances.map { |package| package.properties }
-      expected_packages = [{:name => 'sysmgt.cim.providers.metrics', :ensure => :absent, :status => :broken, :provider => :aix},
-                           {:name => 'sysmgt.cim.providers.osbase', :ensure => '2.12.1.1', :status => :committed, :provider => :aix},
-                           {:name => 'openssl.base', :ensure => :absent, :status => :inconsistent, :provider => :aix}]
-
-      expect(installed_packages).to eql(expected_packages)
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:appdmg) do
-  let(:resource) { Puppet::Type.type(:package).new(:name => 'foo', :provider => :appdmg) }
-  let(:provider) { described_class.new(resource) }
-
-  describe "when installing an appdmg" do
-    let(:fake_mountpoint) { "/tmp/dmg.foo" }
-    let(:fake_hdiutil_plist) { {"system-entities" => [{"mount-point" => fake_mountpoint}]} }
-
-    before do
-      fh = double('filehandle', path: '/tmp/foo')
-      resource[:source] = "foo.dmg"
-      allow(File).to receive(:open).and_yield(fh)
-      allow(Dir).to receive(:mktmpdir).and_return("/tmp/testtmp123")
-      allow(FileUtils).to receive(:remove_entry_secure)
-    end
-
-    describe "from a remote source" do
-      let(:tmpdir) { "/tmp/good123" }
-
-      before :each do
-        resource[:source] = "http://fake.puppetlabs.com/foo.dmg"
-      end
-
-      it "should call tmpdir and use the returned directory" do
-        expect(Dir).to receive(:mktmpdir).and_return(tmpdir)
-        allow(Dir).to receive(:entries).and_return(["foo.app"])
-        expect(described_class).to receive(:curl) do |*args|
-          expect(args[0]).to eq("-o")
-          expect(args[1]).to include(tmpdir)
-          expect(args).not_to include("-k")
-        end
-        allow(described_class).to receive(:hdiutil).and_return('a plist')
-        expect(Puppet::Util::Plist).to receive(:parse_plist).with('a plist').and_return(fake_hdiutil_plist)
-        expect(described_class).to receive(:installapp)
-
-        provider.install
-      end
-    end
-  end
-end

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

@@ -1,302 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:apt) do
-  let(:name) { 'asdf' }
-
-  let(:resource) do
-    Puppet::Type.type(:package).new(
-      :name     => name,
-      :provider => 'apt'
-    )
-  end
-
-  let(:provider) do
-    resource.provider
-  end
-
-  it "should be the default provider on :osfamily => Debian" do
-    expect(Facter).to receive(:value).with(:osfamily).and_return("Debian")
-    expect(described_class.default?).to be_truthy
-  end
-
-  it "should be versionable" do
-    expect(described_class).to be_versionable
-  end
-
-  it "should use :install to update" do
-    expect(provider).to receive(:install)
-    provider.update
-  end
-
-  it "should use 'apt-get remove' to uninstall" do
-    expect(provider).to receive(:aptget).with("-y", "-q", :remove, name)
-    expect(provider).to receive(:properties).and_return({:mark => :none})
-    provider.uninstall
-  end
-
-  it "should use 'apt-get purge' and 'dpkg purge' to purge" do
-    expect(provider).to receive(:aptget).with("-y", "-q", :remove, "--purge", name)
-    expect(provider).to receive(:dpkg).with("--purge", name)
-    expect(provider).to receive(:properties).and_return({:mark => :none})
-    provider.purge
-  end
-
-  it "should use 'apt-cache policy' to determine the latest version of a package" do
-    expect(provider).to receive(:aptcache).with(:policy, name).and_return(<<-HERE)
-#{name}:
-Installed: 1:1.0
-Candidate: 1:1.1
-Version table:
-1:1.0
-  650 http://ftp.osuosl.org testing/main Packages
-*** 1:1.1
-  100 /var/lib/dpkg/status
-    HERE
-
-    expect(provider.latest).to eq("1:1.1")
-  end
-
-  it "should print and error and return nil if no policy is found" do
-    expect(provider).to receive(:aptcache).with(:policy, name).and_return("#{name}:")
-
-    expect(provider).to receive(:err)
-    expect(provider.latest).to be_nil
-  end
-
-  it "should be able to preseed" do
-    expect(provider).to respond_to(:run_preseed)
-  end
-
-  it "should preseed with the provided responsefile when preseeding is called for" do
-    resource[:responsefile] = '/my/file'
-    expect(Puppet::FileSystem).to receive(:exist?).with('/my/file').and_return(true)
-
-    expect(provider).to receive(:info)
-    expect(provider).to receive(:preseed).with('/my/file')
-
-    provider.run_preseed
-  end
-
-  it "should not preseed if no responsefile is provided" do
-    expect(provider).to receive(:info)
-    expect(provider).not_to receive(:preseed)
-
-    provider.run_preseed
-  end
-
-  describe ".instances" do
-    before do
-      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([provider])
-    end
-
-    context "when package is manual marked" do
-      before do
-        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
-      end
-
-      it 'sets mark to manual' do
-        expect(described_class.instances.map(&:mark)).to eq([:manual])
-      end
-    end
-
-    context 'when package is not manual marked ' do
-      before do
-        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
-      end
-
-      it 'does not set mark to manual' do
-        expect(described_class.instances.map(&:mark)).to eq([nil])
-      end
-    end
-  end
-
-  describe 'query' do
-    before do
-      allow(provider).to receive(:dpkgquery).and_return("name: #{resource.name}" )
-    end
-
-
-    context 'when package is not installed on the system' do
-      it 'does not set mark to manual' do
-        result = provider.query
-
-        expect(described_class).not_to receive(:aptmark)
-        expect(result[:mark]).to be_nil
-      end
-    end
-  end
-
-  describe 'flush' do
-
-    context "when package is manual marked" do
-      before do
-        provider.mark = :manual
-      end
-
-      it 'does not call aptmark' do
-        expect(provider).not_to receive(:aptmark)
-        provider.flush
-      end
-    end
-
-    context 'when package is not manual marked ' do
-      it 'calls aptmark' do
-        expect(described_class).to receive(:aptmark).with('manual', resource.name)
-        provider.flush
-      end
-    end
-  end
-
-  describe "when installing" do
-    it "should preseed if a responsefile is provided" do
-      resource[:responsefile] = "/my/file"
-      expect(provider).to receive(:run_preseed)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-      allow(provider).to receive(:aptget)
-      provider.install
-    end
-
-    it "should check for a cdrom" do
-      expect(provider).to receive(:checkforcdrom)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-      allow(provider).to receive(:aptget)
-      provider.install
-    end
-
-    it "should use 'apt-get install' with the package name if no version is asked for" do
-      resource[:ensure] = :installed
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command[-1]).to eq(name)
-        expect(command[-2]).to eq(:install)
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should specify the package version if one is asked for" do
-      resource[:ensure] = '1.0'
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command[-1]).to eq("#{name}=1.0")
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should select latest available version if range is specified" do
-      resource[:ensure] = '>60.0'
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command[-1]).to eq("#{name}=72.0.1+build1-0ubuntu0.19.04.1")
-      end
-      expect(provider).to receive(:aptcache).with(:madison, name).and_return(<<-HERE)
-   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://ro.archive.ubuntu.com/ubuntu disco-updates/main amd64 Packages
-   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://security.ubuntu.com/ubuntu disco-security/main amd64 Packages
-   #{name} | 66.0.3+build1-0ubuntu1 | http://ro.archive.ubuntu.com/ubuntu disco/main amd64 Packages
-    HERE
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should pass through ensure is no version can be selected" do
-      resource[:ensure] = '>74.0'
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command[-1]).to eq("#{name}=>74.0")
-      end
-      expect(provider).to receive(:aptcache).with(:madison, name).and_return(<<-HERE)
-   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://ro.archive.ubuntu.com/ubuntu disco-updates/main amd64 Packages
-   #{name} | 72.0.1+build1-0ubuntu0.19.04.1 | http://security.ubuntu.com/ubuntu disco-security/main amd64 Packages
-   #{name} | 66.0.3+build1-0ubuntu1 | http://ro.archive.ubuntu.com/ubuntu disco/main amd64 Packages
-    HERE
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should use --force-yes if a package version is specified" do
-      resource[:ensure] = '1.0'
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("--force-yes")
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should do a quiet install" do
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("-q")
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should default to 'yes' for all questions" do
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("-y")
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should keep config files if asked" do
-      resource[:configfiles] = :keep
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("DPkg::Options::=--force-confold")
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should replace config files if asked" do
-      resource[:configfiles] = :replace
-      expect(provider).to receive(:aptget) do |*command|
-        expect(command).to include("DPkg::Options::=--force-confnew")
-      end
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it 'should support string install options' do
-      resource[:install_options] = ['--foo', '--bar']
-      expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it 'should support hash install options' do
-      resource[:install_options] = ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
-      expect(provider).to receive(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should install using the source attribute if present" do
-      resource[:ensure] = :installed
-      resource[:source] = '/my/local/package/file'
-
-      expect(provider).to receive(:aptget).with(any_args, :install, resource[:source])
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-
-      provider.install
-    end
-
-    it "should install specific version using the source attribute if present" do
-      resource[:ensure] = '1.2.3'
-      resource[:source] = '/my/local/package/file'
-
-      expect(provider).to receive(:aptget).with(any_args, :install, resource[:source])
-      expect(provider).to receive(:properties).and_return({:mark => :none})
-      expect(provider).to receive(:query).and_return({:ensure => '1.2.3'})
-
-      provider.install
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:aptitude) do
-  let :type do Puppet::Type.type(:package) end
-  let :pkg do
-    type.new(:name => 'faff', :provider => :aptitude, :source => '/tmp/faff.deb')
-  end
-
-  it { is_expected.to be_versionable }
-
-  context "when retrieving ensure" do
-    let(:dpkgquery_path) { '/bin/dpkg-query' }
-
-    before do
-      allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
-      allow(described_class).to receive(:aptmark).with('showmanual', 'faff').and_return("")
-    end
-
-    { :absent   => "deinstall ok config-files faff 1.2.3-1\n",
-      "1.2.3-1" => "install ok installed faff 1.2.3-1\n",
-    }.each do |expect, output|
-      it "detects #{expect} packages" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
-          {:failonfail => true, :combine => true, :custom_environment => {}}
-        ).and_return(Puppet::Util::Execution::ProcessOutput.new(output, 0))
-
-        expect(pkg.property(:ensure).retrieve).to eq(expect)
-      end
-    end
-  end
-
-  it "installs when asked" do
-    expect(pkg.provider).to receive(:aptitude).
-      with('-y', '-o', 'DPkg::Options::=--force-confold', :install, 'faff').
-      and_return(0)
-    expect(pkg.provider).to receive(:properties).and_return({:mark => :none})
-
-    pkg.provider.install
-  end
-
-  it "purges when asked" do
-    expect(pkg.provider).to receive(:aptitude).with('-y', 'purge', 'faff').and_return(0)
-    pkg.provider.purge
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:aptrpm) do
-  let :type do Puppet::Type.type(:package) end
-  let :pkg do
-    type.new(:name => 'faff', :provider => :aptrpm, :source => '/tmp/faff.rpm')
-  end
-
-  it { is_expected.to be_versionable }
-
-  context "when retrieving ensure" do
-    before(:each) do
-      allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
-      allow(pkg.provider).to receive(:which).with("rpm").and_return("/bin/rpm")
-      expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).and_return(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most(:once)
-    end
-
-    def rpm_args
-      ['-q', 'faff', '--nosignature', '--nodigest', '--qf', "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\\n"]
-    end
-
-    it "should report purged packages" do
-      expect(pkg.provider).to receive(:rpm).and_raise(Puppet::ExecutionFailure, "couldn't find rpm")
-      expect(pkg.property(:ensure).retrieve).to eq(:purged)
-    end
-
-    it "should report present packages correctly" do
-      expect(pkg.provider).to receive(:rpm).and_return("faff-1.2.3-1 0 1.2.3-1 5 i686\n")
-      expect(pkg.property(:ensure).retrieve).to eq("1.2.3-1-5")
-    end
-  end
-
-  it "should try and install when asked" do
-    expect(pkg.provider).to receive(:aptget).with('-q', '-y', 'install', 'faff').and_return(0)
-    pkg.provider.install
-  end
-
-  it "should try and purge when asked" do
-    expect(pkg.provider).to receive(:aptget).with('-y', '-q', 'remove', '--purge', 'faff').and_return(0)
-    pkg.provider.purge
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/package'
-
-Puppet::Type.type(:package).provide(:test_base_provider, parent: Puppet::Provider::Package) do
-  def query; end
-end
-
-describe Puppet::Provider::Package do
-  let(:provider) {  Puppet::Type.type(:package).provider(:test_base_provider).new }
-
-  it 'returns absent for uninstalled packages when not purgeable' do
-    expect(provider.properties[:ensure]).to eq(:absent)
-  end
-
-  it 'returns purged for uninstalled packages when purgeable' do
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
-    expect(provider.properties[:ensure]).to eq(:purged)
-  end
-end

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

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-# Note that much of the functionality of the dnf provider is already tested with yum provider tests,
-# as yum is the parent provider.
-describe Puppet::Type.type(:package).provider(:dnf) do
-  context 'default' do
-    (19..21).each do |ver|
-      it "should not be the default provider on fedora#{ver}" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
-        expect(described_class).to_not be_default
-      end
-    end
-
-    (22..26).each do |ver|
-      it "should be the default provider on fedora#{ver}" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-        allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("#{ver}")
-        expect(described_class).to be_default
-      end
-    end
-
-    it "should not be the default provider on rhel7" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("7")
-      expect(described_class).to_not be_default
-    end
-
-    it "should be the default provider on some random future fedora" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:fedora)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8675")
-      expect(described_class).to be_default
-    end
-
-    it "should be the default provider on rhel8" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("8")
-      expect(described_class).to be_default
-    end
-
-    it "should be the default provider on Amazon Linux 2023" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return(:amazon)
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("2023")
-      expect(described_class).to be_default
-    end
-  end
-
-  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
-
-  it_behaves_like 'RHEL package provider', described_class, 'dnf'
-end