puppet 5.0.0 → 6.0.0

data/spec/unit/util/http_proxy_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 require 'puppet/util/http_proxy'
 
 describe Puppet::Util::HttpProxy do
+  include Puppet::Network::HTTP::Compression.module
+
   before(:all) do
     ENV['http_proxy'] = nil
     ENV['HTTP_PROXY'] = nil
@@ -213,4 +215,59 @@ describe Puppet::Util::HttpProxy do
       end
     end
   end
+
+  describe '.request_with_redirects' do
+    let(:dest) { URI.parse('http://mydomain.com/some/path') }
+    let(:http_ok) { stub('http ok', :code => 200, :message => 'HTTP OK') }
+
+    it 'generates accept and accept-encoding headers' do
+      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
+      Net::HTTP.any_instance.expects(:get).with do |_, headers|
+        expect(headers)
+          .to match({'Accept' => '*/*',
+                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+                     'User-Agent' => /Puppet/})
+      end.returns(http_ok)
+
+      subject.request_with_redirects(dest, :get, 0)
+    end
+
+    it 'can return a compressed response body' do
+      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
+
+      compressed_body = [
+        0x1f, 0x8b, 0x08, 0x08, 0xe9, 0x08, 0x7a, 0x5a, 0x00, 0x03,
+        0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0xcb, 0xc8, 0xe4, 0x02,
+        0x00, 0x7a, 0x7a, 0x6f, 0xed, 0x03, 0x00, 0x00, 0x00
+      ].pack('C*')
+
+      response = stub('http ok', :code => 200, :message => 'HTTP OK', :body => compressed_body)
+      response.stubs(:[]).with('content-encoding').returns('gzip')
+      Net::HTTP.any_instance.expects(:get).returns(response)
+
+      expect(
+        uncompress_body(subject.request_with_redirects(dest, :get, 0))
+      ).to eq("hi\n")
+    end
+
+    it 'generates accept and accept-encoding headers when a block is provided' do
+      Net::HTTP.any_instance.stubs(:head).returns(http_ok)
+      Net::HTTP.any_instance.expects(:request_get).with do |_, headers, &block|
+        expect(headers)
+          .to match({'Accept' => '*/*',
+                     'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+                     'User-Agent' => /Puppet/})
+      end.returns(http_ok)
+
+      subject.request_with_redirects(dest, :get, 0) do
+        # unused
+      end
+    end
+
+    it 'only makes a single HEAD request' do
+      Net::HTTP.any_instance.expects(:head).with(anything, anything).returns(http_ok)
+
+      subject.request_with_redirects(dest, :head, 0)
+    end
+  end
 end

data/spec/unit/util/inifile_spec.rb

@@ -159,8 +159,8 @@ describe Puppet::Util::IniConfig::PhysicalFile do
 
     end
 
-    describe "parsing properties" do
-      it "raises an error if the property is not within a section" do
+    describe 'parsing properties' do
+      it 'raises an error if the property is not within a section' do
         text = "key=val\n"
 
         expect {
@@ -169,13 +169,44 @@ describe Puppet::Util::IniConfig::PhysicalFile do
                          /Property with key "key" outside of a section/)
       end
 
-      it "adds the property to the current section" do
+      it 'adds the property to the current section' do
         text = "[main]\nkey=val\n"
 
         subject.parse(text)
         expect(subject.contents).to have(1).items
         sect = subject.contents[0]
-        expect(sect['key']).to eq "val"
+        expect(sect['key']).to eq 'val'
+      end
+
+      context 'with white space' do
+        let(:section) do
+          text = <<-INIFILE
+[main]
+  leading_white_space=value1
+white_space_after_key =value2
+white_space_after_equals= value3
+white_space_after_value=value4\t
+INIFILE
+          subject.parse(text)
+          expect(subject.contents).to have(1).items
+          subject.contents[0]
+        end
+
+        it 'allows and ignores white space before the key' do
+          expect(section['leading_white_space']).to eq('value1')
+        end
+
+        it 'allows and ignores white space before the equals' do
+          expect(section['white_space_after_key']).to eq('value2')
+        end
+
+        it 'allows and ignores white space after the equals' do
+          expect(section['white_space_after_equals']).to eq('value3')
+        end
+
+        it 'allows and ignores white spaces after the value' do
+          expect(section['white_space_after_value']).to eq('value4')
+        end
       end
     end
 

data/spec/unit/util/ldap/manager_spec.rb

@@ -3,22 +3,7 @@ require 'spec_helper'
 
 require 'puppet/util/ldap/manager'
 
-# If the ldap classes aren't available, go ahead and
-# create some, so our tests will pass.
-unless defined?(LDAP::Mod)
-  class LDAP
-    LDAP_MOD_ADD = :adding
-    LDAP_MOD_REPLACE = :replacing
-    LDAP_MOD_DELETE = :deleting
-    class ResultError < RuntimeError; end
-    class Mod
-      def initialize(*args)
-      end
-    end
-  end
-end
-
-describe Puppet::Util::Ldap::Manager do
+describe Puppet::Util::Ldap::Manager, :if => Puppet.features.ldap? do
   before do
     @manager = Puppet::Util::Ldap::Manager.new
   end

data/spec/unit/util/lockfile_spec.rb

@@ -56,7 +56,7 @@ describe Puppet::Util::Lockfile do
     end
 
     # We test simultaneous locks using fork which isn't supported on Windows.
-    it "should not be acquired by another process", :unless => Puppet.features.microsoft_windows? do
+    it "should not be acquired by another process", :unless => Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
       30.times do
         forks = 3
         results = LockfileSpecHelper.run_in_forks(forks) do

data/spec/unit/util/log/destinations_spec.rb

@@ -1,6 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'json'
+require 'puppet/util/json'
 
 require 'puppet/util/log'
 
@@ -47,28 +47,44 @@ describe Puppet::Util::Log.desttypes[:file] do
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
-      let (:abspath) { '/tmp/log' }
-      let (:relpath) { 'log' }
+      describe "with a normal file" do
+        let (:abspath) { '/tmp/log' }
+        let (:relpath) { 'log' }
 
-      it_behaves_like "file destination"
+        it_behaves_like "file destination"
+
+        it "logs an error if it can't chown the file owner & group" do
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
+          Puppet.features.expects(:root?).returns(true)
+          Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
+
+          @class.new(abspath)
+        end
 
-      it "logs an error if it can't chown the file owner & group" do
-        FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
-        Puppet.features.expects(:root?).returns(true)
-        Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
+        it "doesn't attempt to chown when running as non-root" do
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
+          Puppet.features.expects(:root?).returns(false)
 
-        @class.new(abspath)
+          @class.new(abspath)
+        end
       end
 
-      it "doesn't attempt to chown when running as non-root" do
-        FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
-        Puppet.features.expects(:root?).returns(false)
+      describe "with a JSON file" do
+        let (:abspath) { '/tmp/log.json' }
+        let (:relpath) { 'log.json' }
 
-        @class.new(abspath)
+        it_behaves_like "file destination"
+
+        it "should log messages as JSON" do
+          msg = Puppet::Util::Log.new(:level => :info, :message => "don't panic")
+          dest = @class.new(abspath)
+          dest.handle(msg)
+          expect(JSON.parse(File.read(abspath) + ']')).to include(a_hash_including({"message" => "don't panic"}))
+        end
       end
     end
 
-    describe "on Windows systems", :if => Puppet.features.microsoft_windows? do
+    describe "on Windows systems", :if => Puppet::Util::Platform.windows? do
       let (:abspath) { 'C:\\temp\\log.txt' }
       let (:relpath) { 'log.txt' }
 
@@ -143,7 +159,7 @@ describe Puppet::Util::Log.desttypes[:logstash_event] do
     it "format returns a structure that can be converted to json" do
       dest = described_class.new
       hash = dest.format(@msg)
-      JSON.parse(hash.to_json)
+      Puppet::Util::Json.load(hash.to_json)
     end
 
     it "handle should send the output to stdout" do
@@ -207,6 +223,20 @@ describe ":eventlog", :if => Puppet::Util::Platform.windows? do
     expect(Puppet.features.eventlog?).to be_truthy
   end
 
+  it "should truncate extremely long log messages" do
+    long_msg = "x" * 32000
+    expected_truncated_msg = "#{'x' * 31785}...Message exceeds character length limit, truncating."
+    expected_data = "a vogon ship: " + expected_truncated_msg
+
+    eventlog = stub('eventlog')
+    eventlog.expects(:report_event).with(has_entries(:event_type => 2, :event_id => 2, :data => expected_data))
+    msg = Puppet::Util::Log.new(:level => :warning, :message => long_msg, :source => "a vogon ship")
+    Puppet::Util::Windows::EventLog.stubs(:open).returns(eventlog)
+
+    dest = klass.new
+    dest.handle(msg)
+  end
+  
   it "logs to the Puppet Application event log" do
     Puppet::Util::Windows::EventLog.expects(:open).with('Puppet').returns(stub('eventlog'))
 

data/spec/unit/util/log_spec.rb

@@ -1,4 +1,5 @@
 #! /usr/bin/env ruby
+# coding: utf-8
 require 'spec_helper'
 
 require 'puppet/util/log'
@@ -32,11 +33,11 @@ describe Puppet::Util::Log do
     end
 
     it "includes a backtrace in the log" do
-      expect(logs.last.message).to match(/Backtrace:\n.*in `initialize'/ )
+      expect(logs.last.message).to match(/Backtrace:\n.*in `newmessage'\n.*in `initialize'/ )
     end
 
     it "warns that message included invalid encoding" do
-      expect(logs.last.message).to match(/Received a log message with invalid encoding/)
+      expect(logs.last.message).to match(/Received a Log attribute with invalid encoding/)
     end
 
     it "includes the 'dump' of the invalid message" do
@@ -44,9 +45,18 @@ describe Puppet::Util::Log do
     end
   end
 
+  # need a string that cannot be converted to US-ASCII or other encodings easily
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ܎
+
   it "converts a given non-UTF-8 message to UTF-8" do
     logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(logs))
+    Puppet::Util::Log.newdestination(:console)
 
     # HIRAGANA LETTER SO
     # In Windows_31J: \x82 \xbb - 130 187
@@ -54,10 +64,30 @@ describe Puppet::Util::Log do
     win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
     utf_8_msg = "\u305d"
 
-    Puppet::Util::Log.new(:level => :notice, :message => win_31j_msg, :source => 'Puppet')
+    $stdout.expects(:puts).with("\e[mNotice: #{mixed_utf8}: #{utf_8_msg}\e[0m")
+
+    # most handlers do special things with a :source => 'Puppet', so use something else
+    Puppet::Util::Log.new(:level => :notice, :message => win_31j_msg, :source => mixed_utf8)
     expect(logs.last.message).to eq(utf_8_msg)
   end
 
+  it "converts a given non-UTF-8 source to UTF-8" do
+    logs = []
+    Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(logs))
+    Puppet::Util::Log.newdestination(:console)
+
+    # HIRAGANA LETTER SO
+    # In Windows_31J: \x82 \xbb - 130 187
+    # In Unicode: \u305d - \xe3 \x81 \x9d - 227 129 157
+    win_31j_msg = [130, 187].pack('C*').force_encoding(Encoding::Windows_31J)
+    utf_8_msg = "\u305d"
+
+    $stdout.expects(:puts).with("\e[mNotice: #{utf_8_msg}: #{mixed_utf8}\e[0m")
+
+    Puppet::Util::Log.new(:level => :notice, :message => mixed_utf8, :source => win_31j_msg)
+    expect(logs.last.source).to eq(utf_8_msg)
+  end
+
   describe ".setup_default" do
     it "should default to :syslog" do
       Puppet.features.stubs(:syslog?).returns(true)
@@ -220,7 +250,7 @@ describe Puppet::Util::Log do
       end
       expect(logs.size).to eq(1)
       log = logs[0]
-      expect(log.message).to match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.message).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
       expect(log.message).to be(log.to_s)
     end
 
@@ -238,8 +268,8 @@ describe Puppet::Util::Log do
       end
       expect(logs.size).to eq(1)
       log = logs[0]
-      expect(log.message).to_not match(/ at \/tmp\/test\.pp:30:15/)
-      expect(log.to_s).to match(/ at \/tmp\/test\.pp:30:15/)
+      expect(log.message).to_not match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
+      expect(log.to_s).to match(/ \(file: \/tmp\/test\.pp, line: 30, column: 15\)/)
       expect(log.issue_code).to eq(:SYNTAX_ERROR)
       expect(log.file).to eq('/tmp/test.pp')
       expect(log.line).to eq(30)
@@ -298,7 +328,7 @@ describe Puppet::Util::Log do
     end
 
     it "should restrict its suitability to Windows" do
-      Puppet.features.expects(:microsoft_windows?).returns(false)
+      Puppet::Util::Platform.stubs(:windows?).returns false
 
       expect(Puppet::Util::Log::DestEventlog.suitable?('whatever')).to eq(false)
     end
@@ -469,12 +499,12 @@ describe Puppet::Util::Log do
         source.tags = ["tag", "tag2"]
 
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
-        log.expects(:tag).with("file")
-        log.expects(:tag).with("tag")
-        log.expects(:tag).with("tag2")
-
         log.source = source
 
+        expect(log).to be_tagged('file')
+        expect(log).to be_tagged('tag')
+        expect(log).to be_tagged('tag2')
+
         expect(log.source).to eq("/File[#{path}]")
       end
 
@@ -503,7 +533,7 @@ describe Puppet::Util::Log do
       it "should not try to copy over file, version, line, or tag information" do
         source = mock
         source.expects(:file).never
-        log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
+        Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
       end
     end
   end

data/spec/unit/util/logging_spec.rb

@@ -3,6 +3,13 @@ require 'spec_helper'
 
 require 'puppet/util/logging'
 
+Puppet::Type.newtype(:logging_test) do
+  newparam(:name, isnamevar: true)
+  newproperty(:path)
+end
+Puppet::Type.type(:logging_test).provide(:logging_test) do
+end
+
 class LoggingTester
   include Puppet::Util::Logging
 end
@@ -47,7 +54,7 @@ describe Puppet::Util::Logging do
     end
 
     it "should use the path of any provided resource type" do
-      resource = Puppet::Type.type(:host).new :name => "foo"
+      resource = Puppet::Type.type(:logging_test).new :name => "foo"
 
       resource.expects(:path).returns "/path/to/host".to_sym
 
@@ -57,7 +64,7 @@ describe Puppet::Util::Logging do
     end
 
     it "should use the path of any provided resource parameter" do
-      resource = Puppet::Type.type(:host).new :name => "foo"
+      resource = Puppet::Type.type(:logging_test).new :name => "foo"
 
       param = resource.parameter(:name)
 
@@ -154,25 +161,25 @@ describe Puppet::Util::Logging do
     end
 
     it "warns with file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*afile:5/m))
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: afile, line: 5\)/m))
       @logger.puppet_deprecation_warning("deprecated foo", :file => 'afile', :line => 5)
     end
 
     it "warns keyed from file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*afile:5/m)).once
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: afile, line: 5\)/m)).once
       5.times do
         @logger.puppet_deprecation_warning("deprecated foo", :file => 'afile', :line => 5)
       end
     end
 
     it "warns with separate key only once regardless of file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*afile:5/m)).once
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: afile, line: 5\)/m)).once
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key', :file => 'afile', :line => 5)
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key', :file => 'bfile', :line => 3)
     end
 
     it "warns with key but no file and line" do
-      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*unknown:unknown/m))
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*\(file: unknown, line: unknown\)/m))
       @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key')
     end
   end
@@ -184,30 +191,39 @@ describe Puppet::Util::Logging do
     after(:each) {
       # this is required because of bugs in Mocha whe tearing down expectations for each test
       # why it works elsewhere is a mystery.
-      @logger.unstub(:warning)
+      @logger.unstub(:send_log)
     }
 
     it "warns with file when only file is given" do
-      @logger.expects(:warning).with(regexp_matches(/wet paint.*\(in aFile\)/m))
+      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(file: aFile\)/m))
       @logger.warn_once('kind', 'wp', "wet paint", 'aFile')
     end
 
     it "warns with unknown file and line when only line is given" do
-      @logger.expects(:warning).with(regexp_matches(/wet paint.*\(in unknown file, line 5\)/m))
+      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(line: 5\)/m))
       @logger.warn_once('kind', 'wp', "wet paint", nil, 5)
     end
 
     it "warns with file and line when both are given" do
-      @logger.expects(:warning).with(regexp_matches(/wet paint.*\(at aFile:5\)/m))
+      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*\(file: aFile, line: 5\)/m))
       @logger.warn_once('kind', 'wp', "wet paint",'aFile', 5)
     end
 
     it "warns once per key" do
-      @logger.expects(:warning).with(regexp_matches(/wet paint.*/m)).once
+      @logger.expects(:send_log).with(:warning, regexp_matches(/wet paint.*/m)).once
       5.times do
         @logger.warn_once('kind', 'wp', "wet paint")
       end
     end
+
+    Puppet::Util::Log.eachlevel do |level|
+      it "can use log level #{level}" do
+        @logger.expects(:send_log).with(level, regexp_matches(/wet paint.*/m)).once
+        5.times do
+          @logger.warn_once('kind', 'wp', "wet paint", nil, nil, level)
+        end
+      end
+    end
   end
 
   describe "does not warn about undefined variables when disabled_warnings says so" do
@@ -219,11 +235,14 @@ describe Puppet::Util::Logging do
       Puppet[:disable_warnings] = ['undefined_variables']
       example.run
       Puppet[:disable_warnings] = []
-      logger.unstub(:warning)
+    end
+
+    after(:each) do
+      logger.unstub(:send_log)
     end
 
     it "does not produce warning if kind is disabled" do
-      logger.expects(:warning).never
+      logger.expects(:send_log).never
       logger.warn_once('undefined_variables', 'wp', "wet paint")
     end
   end
@@ -237,11 +256,14 @@ describe Puppet::Util::Logging do
       Puppet[:disable_warnings] = ['deprecations']
       example.run
       Puppet[:disable_warnings] = []
-      logger.unstub(:warning)
+    end
+
+    after(:each) do
+      logger.unstub(:send_log)
     end
 
     it "produces warning even if deprecation warnings are disabled " do
-      logger.expects(:warning).once
+      logger.expects(:send_log).with(:warning, regexp_matches(/wet paint/)).once
       logger.warn_once('undefined_variables', 'wp', "wet paint")
     end
   end

data/spec/unit/util/monkey_patches_spec.rb

@@ -20,7 +20,6 @@ describe Symbol do
   end
 
   it "should have an == that is not true for a string with same letters" do
-    pending "JRuby is incompatible with MRI - Cannot test this on JRuby" if RUBY_PLATFORM == 'java'
     symbol = :undef
     expect(symbol == 'undef').to_not be(true)
   end
@@ -42,12 +41,16 @@ describe OpenSSL::SSL::SSLContext do
 
   it 'explicitly disable SSLv2 ciphers using the ! prefix so they cannot be re-added' do
     cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    expect(cipher_str.split(':')).to include('!SSLv2')
+    if cipher_str
+      expect(cipher_str.split(':')).to include('!SSLv2')
+    end
   end
 
   it 'does not exclude SSLv3 ciphers shared with TLSv1' do
     cipher_str = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
-    expect(cipher_str.split(':')).not_to include('!SSLv3')
+    if cipher_str
+      expect(cipher_str.split(':')).not_to include('!SSLv3')
+    end
   end
 
   it 'sets parameters on initialization' do

data/spec/unit/util/plist_spec.rb

@@ -92,8 +92,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(invalid_xml_plist)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with CFFormatError/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
-                                                     {:failonfail => true, :combine => true}).returns(valid_xml_plist)
+      Puppet::Util::Execution.expects(:execute)
+        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+              {:failonfail => true, :combine => true})
+        .returns(Puppet::Util::Execution::ProcessOutput.new(valid_xml_plist, 0))
       expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
     end
     it "returns nil when direct parsing and plutil conversion both fail" do
@@ -101,8 +103,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(non_plist_data)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|NoMethodError)/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
-                                                     {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+              {:failonfail => true, :combine => true})
+        .raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
     it "returns nil when file is a non-plist binary blob" do
@@ -110,8 +114,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       subject.stubs(:open_file_with_args).with(plist_path, 'r:UTF-8').returns(binary_data)
       Puppet.expects(:debug).with(regexp_matches(/^Failed with (CFFormatError|ArgumentError)/))
       Puppet.expects(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '/dev/stdout', plist_path],
-                                                     {:failonfail => true, :combine => true}).raises(Puppet::ExecutionFailure, 'boom')
+      Puppet::Util::Execution.expects(:execute)
+        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
+              {:failonfail => true, :combine => true})
+        .raises(Puppet::ExecutionFailure, 'boom')
       expect(subject.read_plist_file(plist_path)).to eq(nil)
     end
   end

data/spec/unit/util/profiler/object_counts_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 require 'puppet/util/profiler'
 
-describe Puppet::Util::Profiler::ObjectCounts do
+describe Puppet::Util::Profiler::ObjectCounts, unless: Puppet::Util::Platform.jruby? do
+  # ObjectSpace is not enabled by default on JRuby
   it "reports the changes in the system object counts" do
     profiler = Puppet::Util::Profiler::ObjectCounts.new(nil, nil)
 

data/spec/unit/util/rubygems_spec.rb

@@ -14,15 +14,8 @@ describe Puppet::Util::RubyGems::Source do
 
     it "returns Gems18Source if Gem::Specification responds to latest_specs" do
       described_class.expects(:has_rubygems?).returns(true)
-      Gem::Specification.expects(:respond_to?).with(:latest_specs).returns(true)
       expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::Gems18Source)
     end
-
-    it "returns Gems18Source if Gem::Specification does not respond to latest_specs" do
-      described_class.expects(:has_rubygems?).returns(true)
-      Gem::Specification.expects(:respond_to?).with(:latest_specs).returns(false)
-      expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::OldGemsSource)
-    end
   end
 
   describe '::NoGemsSource' do
@@ -51,32 +44,5 @@ describe Puppet::Util::RubyGems::Source do
       described_class.new.clear_paths
     end
   end
-
-  describe '::OldGemsSource' do
-    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::OldGemsSource) }
-
-    it "#directories returns the contents of Gem.latest_load_paths" do
-      Gem.expects(:latest_load_paths).returns([gem_lib])
-
-      expect(described_class.new.directories).to eq([gem_lib])
-    end
-
-    # Older rubygems seem to have a problem with rescanning the gem paths in which they
-    # look for a file in the wrong place and expect it to be there. By caching the first
-    # set of results we don't trigger this bug. This behavior was seen on ruby 1.8.7-p334
-    # using rubygems v1.6.2
-    it "caches the gem paths (works around a bug in older rubygems)" do
-      Gem.expects(:latest_load_paths).returns([gem_lib]).once
-
-      source = described_class.new
-
-      expect(source.directories).to eq([gem_lib])
-    end
-
-    it "#clear_paths calls Gem.clear_paths" do
-      Gem.expects(:clear_paths)
-      described_class.new.clear_paths
-    end
-  end
 end