puppet 7.29.1-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/util/character_encoding_spec.rb

@@ -0,0 +1,186 @@
+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

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,200 @@
+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