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

data/spec/shared_examples/rhel_package_provider.rb

@@ -1,398 +0,0 @@
-shared_examples "RHEL package provider" do |provider_class, provider_name|
-  describe provider_name do
-    let(:name) { 'mypackage' }
-    let(:resource) do
-      Puppet::Type.type(:package).new(
-        :name     => name,
-        :ensure   => :installed,
-        :provider => provider_name
-      )
-    end
-    let(:provider) do
-      provider = provider_class.new
-      provider.resource = resource
-      provider
-    end
-    let(:arch) { 'x86_64' }
-    let(:arch_resource) do
-      Puppet::Type.type(:package).new(
-        :name     => "#{name}.#{arch}",
-        :ensure   => :installed,
-        :provider => provider_name
-      )
-    end
-    let(:arch_provider) do
-      provider = provider_class.new
-      provider.resource = arch_resource
-      provider
-    end
-
-    case provider_name
-    when 'yum'
-      let(:error_level) { '0' }
-    when 'dnf'
-      let(:error_level) { '1' }
-    when 'tdnf'
-      let(:error_level) { '1' }
-    end
-
-    case provider_name
-    when 'yum'
-      let(:upgrade_command) { 'update' }
-    when 'dnf'
-      let(:upgrade_command) { 'upgrade' }
-    when 'tdnf'
-      let(:upgrade_command) { 'upgrade' }
-    end
-
-    before do
-      allow(provider_class).to receive(:command).with(:cmd).and_return("/usr/bin/#{provider_name}")
-      allow(provider).to receive(:rpm).and_return('rpm')
-      allow(provider).to receive(:get).with(:version).and_return('1')
-      allow(provider).to receive(:get).with(:release).and_return('1')
-      allow(provider).to receive(:get).with(:arch).and_return('i386')
-    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 }
-    end
-    # provider should repond to the following methods
-     [:install, :latest, :update, :purge, :install_options].each do |method|
-       it "should have a(n) #{method}" do
-         expect(provider).to respond_to(method)
-      end
-    end
-    describe 'when installing' do
-      before(:each) do
-        allow(Puppet::Util).to receive(:which).with("rpm").and_return("/bin/rpm")
-        allow(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)
-        allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('6')
-      end
-
-      it "should call #{provider_name} install for :installed" do
-        allow(resource).to receive(:should).with(:ensure).and_return(:installed)
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, 'mypackage'])
-        provider.install
-      end
-
-      if provider_name == 'yum'
-        context 'on el-5' do
-          before(:each) do
-            allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('5')
-          end
-
-          it "should catch #{provider_name} install failures when status code is wrong" do
-            allow(resource).to receive(:should).with(:ensure).and_return(:installed)
-            expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-e', error_level, '-y', :install, name]).and_return(Puppet::Util::Execution::ProcessOutput.new("No package #{name} available.", 0))
-            expect {
-              provider.install
-            }.to raise_error(Puppet::Error, "Could not find package #{name}")
-          end
-        end
-      end
-
-      it 'should use :install to update' do
-        expect(provider).to receive(:install)
-        provider.update
-      end
-
-      it 'should be able to set version' do
-        version = '1.2'
-        resource[:ensure] = version
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, "#{name}-#{version}"])
-        allow(provider).to receive(:query).and_return(:ensure => version)
-        provider.install
-      end
-      it 'should handle partial versions specified' do
-        version = '1.3.4'
-        resource[:ensure] = version
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, 'mypackage-1.3.4'])
-        allow(provider).to receive(:query).and_return(:ensure => '1.3.4-1.el6')
-        provider.install
-      end
-
-      it 'should be able to downgrade' do
-        current_version = '1.2'
-        version = '1.0'
-        resource[:ensure] = '1.0'
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :downgrade, "#{name}-#{version}"])
-        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
-        provider.install
-      end
-
-      it 'should be able to upgrade' do
-        current_version = '1.0'
-        version = '1.2'
-        resource[:ensure] = '1.2'
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', upgrade_command, "#{name}-#{version}"])
-        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
-        provider.install
-      end
-
-      it 'should not run upgrade command if absent and ensure latest' do
-        current_version = ''
-        version = '1.2'
-        resource[:ensure] = :latest
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, name])
-        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
-        provider.install
-      end
-
-      it 'should run upgrade command if present and ensure latest' do
-        current_version = '1.0'
-        version = '1.2'
-        resource[:ensure] = :latest
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', upgrade_command, name])
-        allow(provider).to receive(:query).and_return({:ensure => current_version}, {:ensure => version})
-        provider.install
-      end
-
-      it 'should accept install options' do
-        resource[:ensure] = :installed
-        resource[:install_options] = ['-t', {'-x' => 'expackage'}]
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', ['-t', '-x=expackage'], :install, name])
-        provider.install
-      end
-
-      it 'allow virtual packages' do
-        resource[:ensure] = :installed
-        resource[:allow_virtual] = true
-        expect(Puppet::Util::Execution).not_to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :list, name])
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, name])
-        provider.install
-      end
-
-      it 'moves architecture to end of version' do
-        version = '1.2.3'
-        arch_resource[:ensure] = version
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-d', '0', '-e', error_level, '-y', :install, "#{name}-#{version}.#{arch}"])
-        allow(arch_provider).to receive(:query).and_return(:ensure => version)
-        arch_provider.install
-      end
-    end
-
-    describe 'when uninstalling' do
-      it 'should use erase to purge' do
-        expect(Puppet::Util::Execution).to receive(:execute).with(["/usr/bin/#{provider_name}", '-y', :erase, name])
-        provider.purge
-      end
-    end
-
-    it 'should be versionable' do
-      expect(provider).to be_versionable
-    end
-
-    describe 'determining the latest version available for a package' do
-      it "passes the value of enablerepo install_options when querying" do
-        resource[:install_options] = [
-          {'--enablerepo' => 'contrib'},
-          {'--enablerepo' => 'centosplus'},
-        ]
-        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-        expect(described_class).to receive(:latest_package_version).with(name, [], ['contrib', 'centosplus'], [])
-        provider.latest
-      end
-
-      it "passes the value of disablerepo install_options when querying" do
-        resource[:install_options] = [
-          {'--disablerepo' => 'updates'},
-          {'--disablerepo' => 'centosplus'},
-        ]
-        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-        expect(described_class).to receive(:latest_package_version).with(name, ['updates', 'centosplus'], [], [])
-        provider.latest
-      end
-
-      it "passes the value of disableexcludes install_options when querying" do
-        resource[:install_options] = [
-          {'--disableexcludes' => 'main'},
-          {'--disableexcludes' => 'centosplus'},
-        ]
-        allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-        expect(described_class).to receive(:latest_package_version).with(name, [], [], ['main', 'centosplus'])
-        provider.latest
-      end
-
-      describe 'and a newer version is not available' do
-        before :each do
-          allow(described_class).to receive(:latest_package_version).with(name, [], [], []).and_return(nil)
-        end
-
-        it 'raises an error the package is not installed' do
-          allow(provider).to receive(:properties).and_return({:ensure => :absent})
-          expect {
-            provider.latest
-          }.to raise_error(Puppet::DevError, 'Tried to get latest on a missing package')
-        end
-
-        it 'returns version of the currently installed package' do
-          allow(provider).to receive(:properties).and_return({:ensure => '3.4.5'})
-          expect(provider.latest).to eq('3.4.5')
-        end
-      end
-
-      describe 'and a newer version is available' do
-        let(:latest_version) do
-          {
-            :name     => name,
-            :epoch    => '1',
-            :version  => '2.3.4',
-            :release  => '5',
-            :arch     => 'i686',
-          }
-        end
-
-        it 'includes the epoch in the version string' do
-          allow(described_class).to receive(:latest_package_version).with(name, [], [], []).and_return(latest_version)
-          expect(provider.latest).to eq('1:2.3.4-5')
-        end
-      end
-    end
-
-    describe "lazy loading of latest package versions" do
-      before { described_class.clear }
-      after { described_class.clear }
-      let(:mypackage_version) do
-        {
-          :name     => name,
-          :epoch    => '1',
-          :version  => '2.3.4',
-          :release  => '5',
-          :arch     => 'i686',
-        }
-      end
-      let(:mypackage_newerversion) do
-        {
-          :name     => name,
-          :epoch    => '1',
-          :version  => '4.5.6',
-          :release  => '7',
-          :arch     => 'i686',
-        }
-      end
-      let(:latest_versions) { {name => [mypackage_version]} }
-      let(:enabled_versions) { {name => [mypackage_newerversion]} }
-
-      it "returns the version hash if the package was found" do
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
-        version = described_class.latest_package_version(name, [], [], [])
-        expect(version).to eq(mypackage_version)
-      end
-
-      it "is nil if the package was not found in the query" do
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
-        version = described_class.latest_package_version('nopackage', [], [], [])
-        expect(version).to be_nil
-      end
-
-      it "caches the package list and reuses that for subsequent queries" do
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
-        2.times {
-          version = described_class.latest_package_version(name, [], [], [])
-          expect(version).to eq mypackage_version
-        }
-      end
-
-      it "caches separate lists for each combination of 'disablerepo' and 'enablerepo' and 'disableexcludes'" do
-        expect(described_class).to receive(:check_updates).with([], [], []).once.and_return(latest_versions)
-        expect(described_class).to receive(:check_updates).with(['disabled'], ['enabled'], ['disableexcludes']).once.and_return(enabled_versions)
-        2.times {
-          version = described_class.latest_package_version(name, [], [], [])
-          expect(version).to eq mypackage_version
-        }
-        2.times {
-          version = described_class.latest_package_version(name, ['disabled'], ['enabled'], ['disableexcludes'])
-          expect(version).to eq(mypackage_newerversion)
-        }
-      end
-    end
-
-    describe "executing #{provider_name} check-update" do
-      it "passes repos to enable to '#{provider_name} check-update'" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          %W[/usr/bin/#{provider_name} check-update --enablerepo=updates --enablerepo=centosplus],
-          any_args
-        ).and_return(double(:exitstatus => 0))
-        described_class.check_updates([], %W[updates centosplus], [])
-      end
-
-      it "passes repos to disable to '#{provider_name} check-update'" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus],
-          any_args
-        ).and_return(double(:exitstatus => 0))
-        described_class.check_updates(%W[updates centosplus], [], [])
-      end
-
-      it "passes a combination of repos to enable and disable to '#{provider_name} check-update'" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          %W[/usr/bin/#{provider_name} check-update --disablerepo=updates --disablerepo=centosplus --enablerepo=os --enablerepo=contrib ],
-          any_args
-        ).and_return(double(:exitstatus => 0))
-        described_class.check_updates(%W[updates centosplus], %W[os contrib], [])
-      end
-
-      it "passes disableexcludes to '#{provider_name} check-update'" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          %W[/usr/bin/#{provider_name} check-update --disableexcludes=main --disableexcludes=centosplus],
-          any_args
-        ).and_return(double(:exitstatus => 0))
-        described_class.check_updates([], [], %W[main centosplus])
-      end
-
-      it "passes all options to '#{provider_name} check-update'" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          %W[/usr/bin/#{provider_name} check-update --disablerepo=a --disablerepo=b --enablerepo=c --enablerepo=d --disableexcludes=e --disableexcludes=f],
-          any_args
-        ).and_return(double(:exitstatus => 0))
-        described_class.check_updates(%W[a b], %W[c d], %W[e f])
-      end
-
-      it "returns an empty hash if '#{provider_name} check-update' returned 0" do
-        expect(Puppet::Util::Execution).to receive(:execute).and_return(double(:exitstatus => 0))
-        expect(described_class.check_updates([], [], [])).to be_empty
-      end
-
-      it "returns a populated hash if '#{provider_name} check-update returned 100'" do
-        output = double(:exitstatus => 100)
-        expect(Puppet::Util::Execution).to receive(:execute).and_return(output)
-        expect(described_class).to receive(:parse_updates).with(output).and_return({:has => :updates})
-        expect(described_class.check_updates([], [], [])).to eq({:has => :updates})
-      end
-
-      it "returns an empty hash if '#{provider_name} check-update' returned an exit code that was not 0 or 100" do
-        expect(Puppet::Util::Execution).to receive(:execute).and_return(double(:exitstatus => 1))
-        expect(described_class).to receive(:warning).with("Could not check for updates, \'/usr/bin/#{provider_name} check-update\' exited with 1")
-        expect(described_class.check_updates([], [], [])).to eq({})
-      end
-    end
-
-    describe "parsing a line from #{provider_name} check-update" do
-      it "splits up the package name and architecture fields" do
-        checkupdate = %W[curl.i686 7.32.0-10.fc20]
-        parsed = described_class.update_to_hash(*checkupdate)
-        expect(parsed[:name]).to eq 'curl'
-        expect(parsed[:arch]).to eq 'i686'
-      end
-
-      it "splits up the epoch, version, and release fields" do
-        checkupdate = %W[dhclient.i686 12:4.1.1-38.P1.el6.centos]
-        parsed = described_class.update_to_hash(*checkupdate)
-        expect(parsed[:epoch]).to eq '12'
-        expect(parsed[:version]).to eq '4.1.1'
-        expect(parsed[:release]).to eq '38.P1.el6.centos'
-      end
-
-      it "sets the epoch to 0 when an epoch is not specified" do
-        checkupdate = %W[curl.i686 7.32.0-10.fc20]
-        parsed = described_class.update_to_hash(*checkupdate)
-        expect(parsed[:epoch]).to eq '0'
-        expect(parsed[:version]).to eq '7.32.0'
-        expect(parsed[:release]).to eq '10.fc20'
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,240 +0,0 @@
-# NOTE: a lot of the stuff in this file is duplicated in the "puppet_spec_helper" in the project
-#  puppetlabs_spec_helper.  We should probably eat our own dog food and get rid of most of this from here,
-#  and have the puppet core itself use puppetlabs_spec_helper
-
-dir = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift File.join(dir, 'lib')
-
-# Don't want puppet getting the command line arguments for rake
-ARGV.clear
-
-begin
-  require 'rubygems'
-rescue LoadError
-end
-
-require 'puppet'
-
-# Stub out gettext's `_` and `n_()` methods, which attempt to load translations.
-# Several of our mocks (mostly around file system interaction) are broken by
-# FastGettext's implementation of these methods.
-require 'puppet/gettext/stubs'
-
-require 'rspec'
-require 'rspec/its'
-
-# So everyone else doesn't have to include this base constant.
-module PuppetSpec
-  FIXTURE_DIR = File.join(File.expand_path(File.dirname(__FILE__)), "fixtures") unless defined?(FIXTURE_DIR)
-end
-
-require 'pathname'
-require 'tmpdir'
-require 'fileutils'
-
-require 'puppet_spec/verbose'
-require 'puppet_spec/files'
-require 'puppet_spec/settings'
-require 'puppet_spec/fixtures'
-require 'puppet_spec/matchers'
-require 'puppet_spec/unindent'
-require 'puppet/test/test_helper'
-
-Pathname.glob("#{dir}/shared_contexts/*.rb") do |file|
-  require file.relative_path_from(Pathname.new(dir))
-end
-
-Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
-  require behaviour.relative_path_from(Pathname.new(dir))
-end
-
-Pathname.glob("#{dir}/shared_examples/**/*.rb") do |behaviour|
-  require behaviour.relative_path_from(Pathname.new(dir))
-end
-
-require 'webmock/rspec'
-require 'vcr'
-VCR.configure do |vcr|
-  vcr.cassette_library_dir = File.expand_path('vcr/cassettes', PuppetSpec::FIXTURE_DIR)
-  vcr.hook_into :webmock
-  vcr.configure_rspec_metadata!
-  # Uncomment next line to debug vcr
-  # vcr.debug_logger = $stderr
-end
-
-# Disable VCR by default
-VCR.turn_off!
-
-RSpec.configure do |config|
-  include PuppetSpec::Fixtures
-
-  exclude_filters = {}
-  exclude_filters[:benchmark] = true unless ENV['BENCHMARK']
-  config.filter_run_excluding exclude_filters
-
-  config.filter_run_when_matching :focus
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  tmpdir = Puppet::FileSystem.expand_path(Dir.mktmpdir("rspecrun"))
-  oldtmpdir = Puppet::FileSystem.expand_path(Dir.tmpdir())
-  ENV['TMPDIR'] = tmpdir
-
-  Puppet::Test::TestHelper.initialize
-
-  config.before :all do
-    Puppet::Test::TestHelper.before_all_tests()
-    if ENV['PROFILE'] == 'all'
-      require 'ruby-prof'
-      RubyProf.start
-    end
-  end
-
-  config.after :all do
-    if ENV['PROFILE'] == 'all'
-      require 'ruby-prof'
-      result = RubyProf.stop
-      printer = RubyProf::CallTreePrinter.new(result)
-      open(File.join(ENV['PROFILEOUT'],"callgrind.all.#{Time.now.to_i}.trace"), "w") do |f|
-        printer.print(f)
-      end
-    end
-
-    Puppet::Test::TestHelper.after_all_tests()
-  end
-
-  config.before :each do |test|
-    # Disabling garbage collection inside each test, and only running it at
-    # the end of each block, gives us an ~ 15 percent speedup, and more on
-    # some platforms *cough* windows *cough* that are a little slower.
-    GC.disable
-
-    # TODO: in a more sane world, we'd move this logging redirection into our TestHelper class.
-    #  Without doing so, external projects will all have to roll their own solution for
-    #  redirecting logging, and for validating expected log messages.  However, because the
-    #  current implementation of this involves creating an instance variable "@logs" on
-    #  EVERY SINGLE TEST CLASS, and because there are over 1300 tests that are written to expect
-    #  this instance variable to be available--we can't easily solve this problem right now.
-    #
-    # redirecting logging away from console, because otherwise the test output will be
-    #  obscured by all of the log output
-    @logs = []
-    Puppet::Util::Log.close_all
-    if ENV["PUPPET_TEST_LOG_LEVEL"]
-      Puppet::Util::Log.level = ENV["PUPPET_TEST_LOG_LEVEL"].intern
-    end
-    if ENV["PUPPET_TEST_LOG"]
-      Puppet::Util::Log.newdestination(ENV["PUPPET_TEST_LOG"])
-      m = test.metadata
-      Puppet.notice("*** BEGIN TEST #{m[:file_path]}:#{m[:line_number]}")
-    end
-    Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
-
-    @log_level = Puppet::Util::Log.level
-
-    base = PuppetSpec::Files.tmpdir('tmp_settings')
-    Puppet[:vardir] = File.join(base, 'var')
-    Puppet[:publicdir] = File.join(base, 'public')
-    Puppet[:confdir] = File.join(base, 'etc')
-    Puppet[:codedir] = File.join(base, 'code')
-    Puppet[:logdir] = "$vardir/log"
-    Puppet[:rundir] = "$vardir/run"
-    Puppet[:hiera_config] = File.join(base, 'hiera')
-
-    FileUtils.mkdir_p Puppet[:statedir]
-    FileUtils.mkdir_p Puppet[:publicdir]
-
-    Puppet::Test::TestHelper.before_each_test()
-  end
-
-  # Facter 2 uses two versions of the GCE API, so match using regex
-  PUPPET_FACTER_2_GCE_URL = %r{^http://metadata/computeMetadata/v1(beta1)?}.freeze
-  PUPPET_FACTER_3_GCE_URL = "http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json".freeze
-
-  # Facter azure metadata endpoint
-  PUPPET_FACTER_AZ_URL = "http://169.254.169.254/metadata/instance?api-version=2020-09-01"
-
-  # Facter EC2 endpoint
-  PUPPET_FACTER_EC2_METADATA = 'http://169.254.169.254/latest/meta-data/'
-  PUPPET_FACTER_EC2_USERDATA = 'http://169.254.169.254/latest/user-data/'
-
-  config.around :each do |example|
-    # Ignore requests from Facter to external services
-    stub_request(:get, PUPPET_FACTER_2_GCE_URL)
-    stub_request(:get, PUPPET_FACTER_3_GCE_URL)
-    stub_request(:get, PUPPET_FACTER_AZ_URL)
-    stub_request(:get, PUPPET_FACTER_EC2_METADATA)
-    stub_request(:get, PUPPET_FACTER_EC2_USERDATA)
-
-    # Enable VCR if the example is tagged with `:vcr` metadata.
-    if example.metadata[:vcr]
-      VCR.turn_on!
-      begin
-        example.run
-      ensure
-        VCR.turn_off!
-      end
-    else
-      example.run
-    end
-  end
-
-  config.after :each do
-    Puppet::Test::TestHelper.after_each_test()
-
-    # TODO: would like to move this into puppetlabs_spec_helper, but there are namespace issues at the moment.
-    allow(Dir).to receive(:entries).and_call_original
-    PuppetSpec::Files.cleanup
-
-    # TODO: this should be abstracted in the future--see comments above the '@logs' block in the
-    #  "before" code above.
-    #
-    # clean up after the logging changes that we made before each test.
-    @logs.clear
-    Puppet::Util::Log.close_all
-    Puppet::Util::Log.level = @log_level
-
-    # This will perform a GC between tests, but only if actually required.  We
-    # experimented with forcing a GC run, and that was less efficient than
-    # just letting it run all the time.
-    GC.enable
-  end
-
-  config.after :suite do
-    # Log the spec order to a file, but only if the LOG_SPEC_ORDER environment variable is
-    #  set.  This should be enabled on Jenkins runs, as it can be used with Nick L.'s bisect
-    #  script to help identify and debug order-dependent spec failures.
-    if ENV['LOG_SPEC_ORDER']
-      File.open("./spec_order.txt", "w") do |logfile|
-        config.instance_variable_get(:@files_to_run).each { |f| logfile.puts f }
-      end
-    end
-
-    # return to original tmpdir
-    ENV['TMPDIR'] = oldtmpdir
-    FileUtils.rm_rf(tmpdir)
-  end
-
-  if ENV['PROFILE']
-    require 'ruby-prof'
-
-    def profile
-      result = RubyProf.profile { yield }
-      name = RSpec.current_example.metadata[:full_description].downcase.gsub(/[^a-z0-9_-]/, "-").gsub(/-+/, "-")
-      printer = RubyProf::CallTreePrinter.new(result)
-      open(File.join(ENV['PROFILEOUT'],"callgrind.#{name}.#{Time.now.to_i}.trace"), "w") do |f|
-        printer.print(f)
-      end
-    end
-
-    config.around(:each) do |example|
-      if ENV['PROFILE'] == 'each' or (example.metadata[:profile] and ENV['PROFILE'])
-        profile { example.run }
-      else
-        example.run
-      end
-    end
-  end
-end