puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/util/character_encoding_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/character_encoding'
-require 'puppet_spec/character_encoding'
-
-describe Puppet::Util::CharacterEncoding do
-  describe "::convert_to_utf_8" do
-    context "when passed a string that is already UTF-8" do
-      context "with valid encoding" do
-        let(:utf8_string) { "\u06FF\u2603".force_encoding(Encoding::UTF_8) }
-
-        it "should return the string unmodified" do
-          expect(Puppet::Util::CharacterEncoding.convert_to_utf_8(utf8_string)).to eq("\u06FF\u2603".force_encoding(Encoding::UTF_8))
-        end
-
-        it "should not mutate the original string" do
-          expect(utf8_string).to eq("\u06FF\u2603".force_encoding(Encoding::UTF_8))
-        end
-      end
-
-      context "with invalid encoding" do
-        let(:invalid_utf8_string) { "\xfd\xf1".force_encoding(Encoding::UTF_8) }
-
-        it "should issue a debug message" do
-          expect(Puppet).to receive(:debug) { |&b| expect(b.call).to match(/encoding is invalid/) }
-          Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)
-        end
-
-        it "should return the string unmodified" do
-          expect(Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)).to eq("\xfd\xf1".force_encoding(Encoding::UTF_8))
-        end
-
-        it "should not mutate the original string" do
-          Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_utf8_string)
-          expect(invalid_utf8_string).to eq("\xfd\xf1".force_encoding(Encoding::UTF_8))
-        end
-      end
-    end
-
-    context "when passed a string in BINARY encoding" do
-      context "that is valid in Encoding.default_external" do
-        # When received as BINARY are not transcodable, but by "guessing"
-        # Encoding.default_external can transcode to UTF-8
-        let(:win_31j) { [130, 187].pack('C*') } # pack('C*') returns string in BINARY
-
-        it "should be able to convert to UTF-8 by labeling as Encoding.default_external" do
-          # そ - HIRAGANA LETTER SO
-          # In Windows_31J: \x82 \xbb - 130 187
-          # In Unicode: \u305d - \xe3 \x81 \x9d - 227 129 157
-          result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(win_31j)
-          end
-          expect(result).to eq("\u305d")
-          expect(result.bytes.to_a).to eq([227, 129, 157])
-        end
-
-        it "should not mutate the original string" do
-          PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(win_31j)
-          end
-          expect(win_31j).to eq([130, 187].pack('C*'))
-        end
-      end
-
-      context "that is invalid in Encoding.default_external" do
-        let(:invalid_win_31j) { [255, 254, 253].pack('C*') } # these bytes are not valid windows_31j
-
-        it "should return the string umodified" do
-          result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
-          end
-          expect(result.bytes.to_a).to eq([255, 254, 253])
-          expect(result.encoding).to eq(Encoding::BINARY)
-        end
-
-        it "should not mutate the original string" do
-          PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
-          end
-          expect(invalid_win_31j).to eq([255, 254, 253].pack('C*'))
-        end
-
-        it "should issue a debug message that the string was not transcodable" do
-          expect(Puppet).to receive(:debug) { |&b| expect(b.call).to match(/cannot be transcoded/) }
-          PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::Windows_31J) do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(invalid_win_31j)
-          end
-        end
-      end
-
-      context "Given a string labeled as neither UTF-8 nor BINARY" do
-        context "that is transcodable" do
-          let (:shift_jis) { [130, 174].pack('C*').force_encoding(Encoding::Shift_JIS) }
-
-          it "should return a copy of the string transcoded to UTF-8 if it is transcodable" do
-            # http://www.fileformat.info/info/unicode/char/3050/index.htm
-            # ぐ - HIRAGANA LETTER GU
-            # In Shift_JIS: \x82 \xae - 130 174
-            # In Unicode: \u3050 - \xe3 \x81 \x90 - 227 129 144
-            # if we were only ruby > 2.3.0, we could do String.new("\x82\xae", :encoding => Encoding::Shift_JIS)
-
-            result = Puppet::Util::CharacterEncoding.convert_to_utf_8(shift_jis)
-            expect(result).to eq("\u3050".force_encoding(Encoding::UTF_8))
-            # largely redundant but reinforces the point - this was transcoded:
-            expect(result.bytes.to_a).to eq([227, 129, 144])
-          end
-
-          it "should not mutate the original string" do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(shift_jis)
-            expect(shift_jis).to eq([130, 174].pack('C*').force_encoding(Encoding::Shift_JIS))
-          end
-        end
-
-        context "when not transcodable" do
-          # An admittedly contrived case, but perhaps not so improbable
-          # http://www.fileformat.info/info/unicode/char/5e0c/index.htm
-          # 希 Han Character 'rare; hope, expect, strive for'
-          # In EUC_KR: \xfd \xf1 - 253 241
-          # In Unicode: \u5e0c - \xe5 \xb8 \x8c - 229 184 140
-
-          # In this case, this EUC_KR character has been read in as ASCII and is
-          # invalid in that encoding. This would raise an EncodingError
-          # exception on transcode but we catch this issue a debug message -
-          # leaving the original string unaltered.
-          let(:euc_kr) { [253, 241].pack('C*').force_encoding(Encoding::ASCII) }
-
-          it "should issue a debug message" do
-            expect(Puppet).to receive(:debug) { |&b| expect(b.call).to match(/cannot be transcoded/) }
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
-          end
-
-          it "should return the original string unmodified" do
-            result = Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
-            expect(result).to eq([253, 241].pack('C*').force_encoding(Encoding::ASCII))
-          end
-
-          it "should not mutate the original string" do
-            Puppet::Util::CharacterEncoding.convert_to_utf_8(euc_kr)
-            expect(euc_kr).to eq([253, 241].pack('C*').force_encoding(Encoding::ASCII))
-          end
-        end
-      end
-    end
-  end
-
-  describe "::override_encoding_to_utf_8" do
-    context "given a string with bytes that represent valid UTF-8" do
-      # ☃ - unicode snowman
-      # \u2603 - \xe2 \x98 \x83 - 226 152 131
-      let(:snowman) { [226, 152, 131].pack('C*') }
-
-      it "should return a copy of the string with external encoding of the string to UTF-8" do
-        result = Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(snowman)
-        expect(result).to eq("\u2603")
-        expect(result.encoding).to eq(Encoding::UTF_8)
-      end
-
-      it "should not modify the original string" do
-        Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(snowman)
-        expect(snowman).to eq([226, 152, 131].pack('C*'))
-      end
-    end
-
-    context "given a string with bytes that do not represent valid UTF-8" do
-      # Ø - Latin capital letter O with stroke
-      # In ISO-8859-1: \xd8 - 216
-      # Invalid in UTF-8 without transcoding
-      let(:oslash) { [216].pack('C*').force_encoding(Encoding::ISO_8859_1) }
-      let(:foo) { 'foo' }
-
-      it "should issue a debug message" do
-        expect(Puppet).to receive(:debug) { |&b| expect(b.call).to match(/not valid UTF-8/) }
-        Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
-      end
-
-      it "should return the original string unmodified" do
-        result = Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
-        expect(result).to eq([216].pack('C*').force_encoding(Encoding::ISO_8859_1))
-      end
-
-      it "should not modify the string" do
-        Puppet::Util::CharacterEncoding.override_encoding_to_utf_8(oslash)
-        expect(oslash).to eq([216].pack('C*').force_encoding(Encoding::ISO_8859_1))
-      end
-    end
-  end
-end

data/spec/unit/util/checksums_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/checksums'
-
-describe Puppet::Util::Checksums do
-  include PuppetSpec::Files
-
-  before do
-    @summer = Puppet::Util::Checksums
-  end
-
-  content_sums = [:md5, :md5lite, :sha1, :sha1lite, :sha256, :sha256lite, :sha512, :sha384, :sha224]
-  file_only = [:ctime, :mtime, :none]
-
-  content_sums.each do |sumtype|
-    it "should be able to calculate #{sumtype} sums from strings" do
-      expect(@summer).to be_respond_to(sumtype)
-    end
-  end
-
-  content_sums.each do |sumtype|
-    it "should know the expected length of #{sumtype} sums" do
-      expect(@summer).to be_respond_to(sumtype.to_s + "_hex_length")
-    end
-  end
-
-  [content_sums, file_only].flatten.each do |sumtype|
-    it "should be able to calculate #{sumtype} sums from files" do
-      expect(@summer).to be_respond_to(sumtype.to_s + "_file")
-    end
-  end
-
-  [content_sums, file_only].flatten.each do |sumtype|
-    it "should be able to calculate #{sumtype} sums from stream" do
-      expect(@summer).to be_respond_to(sumtype.to_s + "_stream")
-    end
-  end
-
-  it "should have a method for determining whether a given string is a checksum" do
-    expect(@summer).to respond_to(:checksum?)
-  end
-
-  %w{{md5}asdfasdf {sha1}asdfasdf {ctime}asdasdf {mtime}asdfasdf 
-     {sha256}asdfasdf {sha256lite}asdfasdf {sha512}asdfasdf {sha384}asdfasdf {sha224}asdfasdf}.each do |sum|
-    it "should consider #{sum} to be a checksum" do
-      expect(@summer).to be_checksum(sum)
-    end
-  end
-
-  %w{{nosuchsumthislong}asdfasdf {a}asdfasdf {ctime}}.each do |sum|
-    it "should not consider #{sum} to be a checksum" do
-      expect(@summer).not_to be_checksum(sum)
-    end
-  end
-
-  it "should have a method for stripping a sum type from an existing checksum" do
-    expect(@summer.sumtype("{md5}asdfasdfa")).to eq("md5")
-  end
-
-  it "should have a method for stripping the data from a checksum" do
-    expect(@summer.sumdata("{md5}asdfasdfa")).to eq("asdfasdfa")
-  end
-
-  it "should return a nil sumtype if the checksum does not mention a checksum type" do
-    expect(@summer.sumtype("asdfasdfa")).to be_nil
-  end
-
-  it "has a list of known checksum types" do
-    expect(@summer.known_checksum_types).to match_array(content_sums + file_only)
-  end
-
-  it "returns true if the checksum is valid" do
-    expect(@summer).to be_valid_checksum('sha1', 'fcc1715b22278a9dae322b0a34935f10d1608b9f')
-  end
-
-  it "returns false if the checksum is known but invalid" do
-    expect(@summer).to_not be_valid_checksum('sha1', 'wronglength')
-  end
-
-  it "returns false if the checksum type is unknown" do
-    expect(@summer).to_not be_valid_checksum('rot13', 'doesntmatter')
-  end
-
-  {:md5 => Digest::MD5, :sha1 => Digest::SHA1, :sha256 => Digest::SHA256, :sha512 => Digest::SHA512, :sha384 => Digest::SHA384}.each do |sum, klass|
-    describe("when using #{sum}") do
-      it "should use #{klass} to calculate string checksums" do
-        expect(klass).to receive(:hexdigest).with("mycontent").and_return("whatever")
-        expect(@summer.send(sum, "mycontent")).to eq("whatever")
-      end
-
-      it "should use incremental #{klass} sums to calculate file checksums" do
-        digest = double('digest')
-        expect(klass).to receive(:new).and_return(digest)
-
-        file = "/path/to/my/file"
-
-        fh = double('filehandle')
-        expect(fh).to receive(:read).with(4096).exactly(3).times().and_return("firstline", "secondline", nil)
-
-        expect(File).to receive(:open).with(file, "rb").and_yield(fh)
-
-        expect(digest).to receive(:<<).with("firstline")
-        expect(digest).to receive(:<<).with("secondline")
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
-
-        expect(@summer.send(sum.to_s + "_file", file)).to eq(:mydigest)
-      end
-
-      it "should behave like #{klass} to calculate stream checksums" do
-        digest = double('digest')
-        expect(klass).to receive(:new).and_return(digest)
-        expect(digest).to receive(:<<).with "firstline"
-        expect(digest).to receive(:<<).with "secondline"
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
-
-        expect(@summer.send(sum.to_s + "_stream") do |checksum|
-          checksum << "firstline"
-          checksum << "secondline"
-        end).to eq(:mydigest)
-      end
-    end
-  end
-
-  {:md5lite => Digest::MD5, :sha1lite => Digest::SHA1, :sha256lite => Digest::SHA256}.each do |sum, klass|
-    describe("when using #{sum}") do
-      it "should use #{klass} to calculate string checksums from the first 512 characters of the string" do
-        content = "this is a test" * 100
-        expect(klass).to receive(:hexdigest).with(content[0..511]).and_return("whatever")
-        expect(@summer.send(sum, content)).to eq("whatever")
-      end
-
-      it "should use #{klass} to calculate a sum from the first 512 characters in the file" do
-        digest = double('digest')
-        expect(klass).to receive(:new).and_return(digest)
-
-        file = "/path/to/my/file"
-
-        fh = double('filehandle')
-        expect(fh).to receive(:read).with(512).and_return('my content')
-
-        expect(File).to receive(:open).with(file, "rb").and_yield(fh)
-
-        expect(digest).to receive(:<<).with("my content")
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
-
-        expect(@summer.send(sum.to_s + "_file", file)).to eq(:mydigest)
-      end
-
-      it "should use #{klass} to calculate a sum from the first 512 characters in a stream" do
-        digest = double('digest')
-        content = "this is a test" * 100
-        expect(klass).to receive(:new).and_return(digest)
-        expect(digest).to receive(:<<).with(content[0..511])
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
-
-        expect(@summer.send(sum.to_s + "_stream") do |checksum|
-          checksum << content
-        end).to eq(:mydigest)
-      end
-
-      it "should use #{klass} to calculate a sum from the first 512 characters in a multi-part stream" do
-        digest = double('digest')
-        content = "this is a test" * 100
-        expect(klass).to receive(:new).and_return(digest)
-        expect(digest).to receive(:<<).with(content[0..5])
-        expect(digest).to receive(:<<).with(content[6..510])
-        expect(digest).to receive(:<<).with(content[511..511])
-        expect(digest).to receive(:hexdigest).and_return(:mydigest)
-
-        expect(@summer.send(sum.to_s + "_stream") do |checksum|
-          checksum << content[0..5]
-          checksum << content[6..510]
-          checksum << content[511..-1]
-        end).to eq(:mydigest)
-      end
-    end
-  end
-
-  [:ctime, :mtime].each do |sum|
-    describe("when using #{sum}") do
-      it "should use the '#{sum}' on the file to determine the ctime" do
-        file = "/my/file"
-        stat = double('stat', sum => "mysum")
-        expect(Puppet::FileSystem).to receive(:stat).with(file).and_return(stat)
-
-        expect(@summer.send(sum.to_s + "_file", file)).to eq("mysum")
-      end
-
-      it "should return nil for streams" do
-        expectation = double("expectation")
-        expect(expectation).to receive(:do_something!).at_least(:once)
-        expect(@summer.send(sum.to_s + "_stream"){ |checksum| checksum << "anything" ; expectation.do_something!  }).to be_nil
-      end
-    end
-  end
-
-  describe "when using the none checksum" do
-    it "should return an empty string" do
-      expect(@summer.none_file("/my/file")).to eq("")
-    end
-
-    it "should return an empty string for streams" do
-      expectation = double("expectation")
-      expect(expectation).to receive(:do_something!).at_least(:once)
-      expect(@summer.none_stream{ |checksum| checksum << "anything" ; expectation.do_something!  }).to eq("")
-    end
-  end
-
-  {:md5 => Digest::MD5, :sha1 => Digest::SHA1}.each do |sum, klass|
-    describe "when using #{sum}" do
-      let(:content) { "hello\r\nworld" }
-      let(:path) do
-        path = tmpfile("checksum_#{sum}")
-        File.open(path, 'wb') {|f| f.write(content)}
-        path
-      end
-
-      it "should preserve nl/cr sequences" do
-        expect(@summer.send(sum.to_s + "_file", path)).to eq(klass.hexdigest(content))
-      end
-    end
-  end
-end

data/spec/unit/util/colors_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Util::Colors do
-  include Puppet::Util::Colors
-
-  let (:message) { 'a message' }
-  let (:color) { :black }
-  let (:subject) { self }
-
-  describe ".console_color" do
-    it { is_expected.to respond_to :console_color }
-
-    it "should generate ANSI escape sequences" do
-      expect(subject.console_color(color, message)).to eq("\e[0;30m#{message}\e[0m")
-    end
-  end
-
-  describe ".html_color" do
-    it { is_expected.to respond_to :html_color }
-
-    it "should generate an HTML span element and style attribute" do
-      expect(subject.html_color(color, message)).to match(/<span style=\"color: #FFA0A0\">#{message}<\/span>/)
-    end
-  end
-
-  describe ".colorize" do
-    it { is_expected.to respond_to :colorize }
-
-    context "ansicolor supported" do
-      it "should colorize console output" do
-        Puppet[:color] = true
-
-        expect(subject).to receive(:console_color).with(color, message)
-        subject.colorize(:black, message)
-      end
-
-      it "should not colorize unknown color schemes" do
-        Puppet[:color] = :thisisanunknownscheme
-
-        expect(subject.colorize(:black, message)).to eq(message)
-      end
-    end
-  end
-end

data/spec/unit/util/command_line_spec.rb

@@ -1,200 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/face'
-require 'puppet/util/command_line'
-
-describe Puppet::Util::CommandLine do
-  include PuppetSpec::Files
-
-  context "#initialize" do
-    it "should pull off the first argument if it looks like a subcommand" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ client --help whatever.pp })
-
-      expect(command_line.subcommand_name).to eq("client")
-      expect(command_line.args).to            eq(%w{ --help whatever.pp })
-    end
-
-    it "should return nil if the first argument looks like a .pp file" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.pp })
-
-      expect(command_line.subcommand_name).to eq(nil)
-      expect(command_line.args).to            eq(%w{ whatever.pp })
-    end
-
-    it "should return nil if the first argument looks like a flag" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ --debug })
-
-      expect(command_line.subcommand_name).to eq(nil)
-      expect(command_line.args).to            eq(%w{ --debug })
-    end
-
-    it "should return nil if the first argument is -" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ - })
-
-      expect(command_line.subcommand_name).to eq(nil)
-      expect(command_line.args).to            eq(%w{ - })
-    end
-
-    it "should return nil if the first argument is --help" do
-      command_line = Puppet::Util::CommandLine.new("puppet", %w{ --help })
-
-      expect(command_line.subcommand_name).to eq(nil)
-    end
-
-
-    it "should return nil if there are no arguments" do
-      command_line = Puppet::Util::CommandLine.new("puppet", [])
-
-      expect(command_line.subcommand_name).to eq(nil)
-      expect(command_line.args).to            eq([])
-    end
-
-    it "should pick up changes to the array of arguments" do
-      args = %w{subcommand}
-      command_line = Puppet::Util::CommandLine.new("puppet", args)
-      args[0] = 'different_subcommand'
-      expect(command_line.subcommand_name).to eq('different_subcommand')
-    end
-  end
-
-  context "#execute" do
-    %w{--version -V}.each do |arg|
-      it "should print the version and exit if #{arg} is given" do
-        expect do
-          described_class.new("puppet", [arg]).execute
-        end.to output(/^#{Regexp.escape(Puppet.version)}$/).to_stdout
-      end
-    end
-
-    %w{--help -h help}.each do|arg|
-      it "should print help and exit if #{arg} is given" do
-        commandline = Puppet::Util::CommandLine.new("puppet", [arg])
-        expect(commandline).not_to receive(:exec)
-
-        expect {
-          commandline.execute
-        }.to exit_with(0)
-         .and output(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).to_stdout
-      end
-    end
-
-    it "should fail if the config file isn't readable and we're running a subcommand that requires a readable config file" do
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:config]).and_return(true)
-      allow_any_instance_of(Puppet::Settings).to receive(:read_file).and_return('')
-      expect_any_instance_of(Puppet::Settings).to receive(:read_file).with(Puppet[:config]).and_raise('Permission denied')
-
-      expect{ described_class.new("puppet", ['config']).execute }.to raise_error(SystemExit)
-    end
-
-    it "should not fail if the config file isn't readable and we're running a subcommand that does not require a readable config file" do
-      allow(Puppet::FileSystem).to receive(:exist?)
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:config]).and_return(true)
-      allow_any_instance_of(Puppet::Settings).to receive(:read_file).and_return('')
-      expect_any_instance_of(Puppet::Settings).to receive(:read_file).with(Puppet[:config]).and_raise('Permission denied')
-
-      commandline = described_class.new("puppet", ['help'])
-
-      expect {
-        commandline.execute
-      }.to exit_with(0)
-       .and output(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).to_stdout
-    end
-  end
-
-  describe "when dealing with puppet commands" do
-    it "should return the executable name if it is not puppet" do
-      command_line = Puppet::Util::CommandLine.new("puppetmasterd", [])
-      expect(command_line.subcommand_name).to eq("puppetmasterd")
-    end
-
-    describe "when the subcommand is not implemented" do
-      it "should find and invoke an executable with a hyphenated name" do
-        commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
-        expect(Puppet::Util).to receive(:which).with('puppet-whatever').
-          and_return('/dev/null/puppet-whatever')
-
-        expect(Kernel).to receive(:exec).with('/dev/null/puppet-whatever', 'argument')
-
-        commandline.execute
-      end
-
-      describe "and an external implementation cannot be found" do
-        it "should abort and show the usage message" do
-          expect(Puppet::Util).to receive(:which).with('puppet-whatever').and_return(nil)
-          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
-          expect(commandline).not_to receive(:exec)
-
-          expect {
-            commandline.execute
-          }.to exit_with(1)
-           .and output(/Unknown Puppet subcommand 'whatever'/).to_stdout
-        end
-
-        it "should abort and show the help message" do
-          expect(Puppet::Util).to receive(:which).with('puppet-whatever').and_return(nil)
-          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
-          expect(commandline).not_to receive(:exec)
-
-          expect {
-            commandline.execute
-          }.to exit_with(1)
-           .and output(/See 'puppet help' for help on available puppet subcommands/).to_stdout
-        end
-
-        %w{--version -V}.each do |arg|
-          it "should abort and display #{arg} information" do
-            expect(Puppet::Util).to receive(:which).with('puppet-whatever').and_return(nil)
-            commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', arg])
-            expect(commandline).not_to receive(:exec)
-
-            expect {
-              commandline.execute
-            }.to exit_with(1)
-             .and output(%r[^#{Regexp.escape(Puppet.version)}$]).to_stdout
-          end
-        end
-      end
-    end
-
-    describe 'when setting process priority' do
-      let(:command_line) do
-        Puppet::Util::CommandLine.new("puppet", %w{ agent })
-      end
-
-      before :each do
-        allow_any_instance_of(Puppet::Util::CommandLine::ApplicationSubcommand).to receive(:run)
-      end
-
-      it 'should never set priority by default' do
-        expect(Process).not_to receive(:setpriority)
-
-        command_line.execute
-      end
-
-      it 'should lower the process priority if one has been specified' do
-        Puppet[:priority] = 10
-
-        expect(Process).to receive(:setpriority).with(0, Process.pid, 10)
-        command_line.execute
-      end
-
-      it 'should warn if trying to raise priority, but not privileged user' do
-        Puppet[:priority] = -10
-
-        expect(Process).to receive(:setpriority).and_raise(Errno::EACCES, 'Permission denied')
-        expect(Puppet).to receive(:warning).with("Failed to set process priority to '-10'")
-
-        command_line.execute
-      end
-
-      it "should warn if the platform doesn't support `Process.setpriority`" do
-        Puppet[:priority] = 15
-
-        expect(Process).to receive(:setpriority).and_raise(NotImplementedError, 'NotImplementedError: setpriority() function is unimplemented on this machine')
-        expect(Puppet).to receive(:warning).with("Failed to set process priority to '15'")
-
-        command_line.execute
-      end
-    end
-  end
-end