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

data/spec/unit/util/package/version/rpm_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/package/version/rpm'
-
-describe Puppet::Util::Package::Version::Rpm do
-
-  context "when parsing an invalid version" do
-    it "raises ArgumentError" do
-      expect { described_class.parse(:absent)}.to raise_error(ArgumentError)
-    end
-  end
-
-  context "when creating new version" do
-    it "is parsing basic version" do
-      v = described_class.parse('1:2.8.8-1.el6')
-      expect([v.epoch, v.version, v.release, v.arch ]).to eq(['1', '2.8.8', '1.el6' , nil])
-    end
-
-    it "is parsing no epoch basic version" do
-      v = described_class.parse('2.8.8-1.el6')
-      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '2.8.8', '1.el6', nil])
-    end
-
-    it "is parsing no epoch basic short version" do
-      v = described_class.parse('7.15-8.fc29')
-      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '7.15', '8.fc29', nil])
-    end
-
-    it "is parsing no epoch and no release basic version" do
-      v = described_class.parse('2.8.8')
-      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '2.8.8', nil, nil])
-    end
-
-    it "is parsing no epoch complex version" do
-      v = described_class.parse('1.4-0.24.20120830CVS.fc31')
-      expect([v.epoch, v.version, v.release, v.arch ]).to eq([nil, '1.4', '0.24.20120830CVS.fc31', nil])
-    end
-  end
-
-  context "when comparing two versions" do
-    context 'with invalid version' do
-      it 'raises ArgumentError' do
-        version = described_class.parse('0:1.5.3-3.el6')
-        invalid = 'invalid'
-        expect { version < invalid }.to \
-          raise_error(ArgumentError, 'Cannot compare, as invalid is not a Rpm Version')
-      end
-    end
-
-    context 'with valid versions' do
-      it "epoch has precedence" do
-        lower = described_class.parse('0:1.5.3-3.el6')
-        higher = described_class.parse('1:1.7.0-15.fc29')
-        expect(lower).to be < higher
-      end
-
-      it 'handles no epoch as 0 epoch' do
-        lower = described_class.parse('1.5.3-3.el6')
-        higher = described_class.parse('1:1.7.0-15.fc29')
-        expect(lower).to be < higher
-      end
-
-      it "handles equals letters-only versions" do
-        first = described_class.parse('abd-def')
-        second = described_class.parse('abd-def')
-        expect(first).to eq(second)
-      end
-
-      it "shorter version is smaller letters-only versions" do
-        lower = described_class.parse('ab')
-        higher = described_class.parse('abd')
-        expect(lower).to be < higher
-      end
-
-      it "shorter version is smaller even with digits" do
-        lower = described_class.parse('1.7')
-        higher = described_class.parse('1.7.0')
-        expect(lower).to be < higher
-      end
-
-      it "shorter version is smaller when number is less" do
-        lower = described_class.parse('1.7.0')
-        higher = described_class.parse('1.7.1')
-        expect(lower).to be < higher
-      end
-
-      it "shorter release is smaller " do
-        lower = described_class.parse('1.7.0-11.fc26')
-        higher = described_class.parse('1.7.0-11.fc27')
-        expect(lower).to be < higher
-      end
-
-      it "release letters are smaller letters-only" do
-        lower = described_class.parse('1.7.0-abc')
-        higher = described_class.parse('1.7.0-abd')
-        expect(lower).to be < higher
-      end
-
-      it "shorter release is smaller" do
-        lower = described_class.parse('1.7.0-11.fc2')
-        higher = described_class.parse('1.7.0-11.fc17')
-        expect(lower).to be < higher
-      end
-
-      it "handles equal release" do
-        first = described_class.parse('1.7.0-11.fc27')
-        second = described_class.parse('1.7.0-11.fc27')
-        expect(first).to eq(second)
-      end
-    end
-
-    context 'when one has no epoch' do
-      it 'handles no epoch as zero' do
-        version1 = described_class.parse('1:1.2')
-        version2 = described_class.parse('1.4')
-
-        expect(version1).to be > version2
-        expect(version2).to be < version1
-      end
-    end
-  end
-end

data/spec/unit/util/package_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/package'
-
-describe Puppet::Util::Package, " versioncmp" do
-
-  it "should be able to be used as a module function" do
-    expect(Puppet::Util::Package).to respond_to(:versioncmp)
-  end
-
-  it "should be able to sort a long set of various unordered versions" do
-    ary = %w{ 1.1.6 2.3 1.1a 3.0 1.5 1 2.4 1.1-4 2.3.1 1.2 2.3.0 1.1-3 2.4b 2.4 2.40.2 2.3a.1 3.1 0002 1.1-5 1.1.a 1.06}
-
-    newary = ary.sort { |a, b| Puppet::Util::Package.versioncmp(a,b) }
-
-    expect(newary).to eq(["0002", "1", "1.06", "1.1-3", "1.1-4", "1.1-5", "1.1.6", "1.1.a", "1.1a", "1.2", "1.5", "2.3", "2.3.0", "2.3.1", "2.3a.1", "2.4", "2.4", "2.4b", "2.40.2", "3.0", "3.1"])
-  end
-
-end

data/spec/unit/util/pidlock_spec.rb

@@ -1,333 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/util/pidlock'
-
-describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
-  require 'puppet_spec/files'
-  include PuppetSpec::Files
-
-  before(:each) do
-    @lockfile = tmpfile("lock")
-    @lock = Puppet::Util::Pidlock.new(@lockfile)
-    allow(Facter).to receive(:value).with(:kernel).and_return('Linux')
-  end
-
-  describe "#ps pid argument on posix", unless: Puppet::Util::Platform.windows? do
-    let(:other_pid) { Process.pid + 1 }
-
-    before do
-      # another process has locked the pidfile
-      File.write(@lockfile, other_pid)
-
-      # and it's still active
-      allow(Process).to receive(:kill).with(0, other_pid)
-    end
-
-    it "should fallback to '-p' when ps execution fails with '-eq' on Linux" do
-      allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', other_pid, '-o', 'comm=']).and_raise(Puppet::ExecutionFailure, 'Execution of command returned 1: error')
-
-      expect(Puppet::Util::Execution).to receive(:execute).with(['ps', "-p", other_pid, '-o', 'comm=']).and_return('puppet')
-      expect(Puppet::Util::Execution).to receive(:execute).with(['ps', "-p", other_pid, '-o', 'args=']).and_return('puppet')
-
-      expect(@lock).to be_locked
-    end
-
-    shared_examples_for 'a valid ps argument was provided' do |desired_kernel, ps_argument|
-      it "should be '#{ps_argument}' when current kernel is #{desired_kernel}" do
-        allow(Facter).to receive(:value).with(:kernel).and_return(desired_kernel)
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', ps_argument, other_pid, '-o', 'comm=']).and_return('ruby')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', ps_argument, other_pid, '-o', 'args=']).and_return('puppet')
-        expect(@lock).to be_locked
-      end
-    end
-
-    context "when current kernel is Linux" do
-      it_should_behave_like 'a valid ps argument was provided', "Linux", "-eq"
-    end
-
-    context "when current kernel is AIX" do
-      it_should_behave_like 'a valid ps argument was provided', "AIX", "-T"
-    end
-
-    context "when current kernel is Darwin" do
-      it_should_behave_like 'a valid ps argument was provided', "Darwin", "-p"
-    end
-  end
-
-  describe "#lock" do
-    it "should not be locked at start" do
-      expect(@lock).not_to be_locked
-    end
-
-    it "should not be mine at start" do
-      expect(@lock).not_to be_mine
-    end
-
-    it "should become locked" do
-      @lock.lock
-      expect(@lock).to be_locked
-    end
-
-    it "should become mine" do
-      @lock.lock
-      expect(@lock).to be_mine
-    end
-
-    it "should be possible to lock multiple times" do
-      @lock.lock
-      expect { @lock.lock }.not_to raise_error
-    end
-
-    it "should return true when locking" do
-      expect(@lock.lock).to be_truthy
-    end
-
-    it "should return true if locked by me" do
-      @lock.lock
-      expect(@lock.lock).to be_truthy
-    end
-
-    it "should create a lock file" do
-      @lock.lock
-      expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
-    end
-
-    it 'should create an empty lock file even when pid is missing' do
-      allow(Process).to receive(:pid).and_return('')
-      @lock.lock
-      expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
-      expect(Puppet::FileSystem.read(@lock.file_path)).to be_empty
-    end
-
-    it 'should replace an existing empty lockfile with a pid, given a subsequent lock call made against a valid pid' do
-      # empty pid results in empty lockfile
-      allow(Process).to receive(:pid).and_return('')
-      @lock.lock
-      expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
-
-      # next lock call with valid pid kills existing empty lockfile
-      allow(Process).to receive(:pid).and_return(1234)
-      @lock.lock
-      expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_truthy
-      expect(Puppet::FileSystem.read(@lock.file_path)).to eq('1234')
-    end
-
-    it "should expose the lock file_path" do
-      expect(@lock.file_path).to eq(@lockfile)
-    end
-  end
-
-  describe "#unlock" do
-    it "should not be locked anymore" do
-      @lock.lock
-      @lock.unlock
-      expect(@lock).not_to be_locked
-    end
-
-    it "should return false if not locked" do
-      expect(@lock.unlock).to be_falsey
-    end
-
-    it "should return true if properly unlocked" do
-      @lock.lock
-      expect(@lock.unlock).to be_truthy
-    end
-
-    it "should get rid of the lock file" do
-      @lock.lock
-      @lock.unlock
-      expect(Puppet::FileSystem.exist?(@lockfile)).to be_falsey
-    end
-  end
-
-  describe "#locked?" do
-    it "should return true if locked" do
-      @lock.lock
-      expect(@lock).to be_locked
-    end
-
-    it "should remove the lockfile when pid is missing" do
-      allow(Process).to receive(:pid).and_return('')
-      @lock.lock
-      expect(@lock.locked?).to be_falsey
-      expect(Puppet::FileSystem.exist?(@lock.file_path)).to be_falsey
-    end
-  end
-
-  describe '#lock_pid' do
-    it 'should return nil if the pid is empty' do
-      # fake pid to get empty lockfile
-      allow(Process).to receive(:pid).and_return('')
-      @lock.lock
-      expect(@lock.lock_pid).to eq(nil)
-    end
-  end
-
-  describe "with a stale lock" do
-    before(:each) do
-      # fake our pid to be 1234
-      allow(Process).to receive(:pid).and_return(1234)
-      # lock the file
-      @lock.lock
-      # fake our pid to be a different pid, to simulate someone else
-      #  holding the lock
-      allow(Process).to receive(:pid).and_return(6789)
-
-      allow(Process).to receive(:kill).with(0, 6789)
-      allow(Process).to receive(:kill).with(0, 1234).and_raise(Errno::ESRCH)
-    end
-
-    it "should not be locked" do
-      expect(@lock).not_to be_locked
-    end
-
-    describe "#lock" do
-      it "should clear stale locks" do
-        expect(@lock.locked?).to be_falsey
-        expect(Puppet::FileSystem.exist?(@lockfile)).to be_falsey
-      end
-
-      it "should replace with new locks" do
-        @lock.lock
-        expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
-        expect(@lock.lock_pid).to eq(6789)
-        expect(@lock).to be_mine
-        expect(@lock).to be_locked
-      end
-    end
-
-    describe "#unlock" do
-      it "should not be allowed" do
-        expect(@lock.unlock).to be_falsey
-      end
-
-      it "should not remove the lock file" do
-        @lock.unlock
-        expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
-      end
-    end
-  end
-
-  describe "with no access to open the process on Windows", :if => Puppet.features.microsoft_windows? do
-    before(:each) do
-      allow(Process).to receive(:pid).and_return(6789)
-      @lock.lock
-      allow(Process).to receive(:pid).and_return(1234)
-      exception = Puppet::Util::Windows::Error.new('Access Denied', 5) # ERROR_ACCESS_DENIED
-      allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_raise(exception)
-      allow(Process).to receive(:kill).with(0, 6789)
-      allow(Process).to receive(:kill).with(0, 1234)
-    end
-
-    it "should be locked" do
-      expect(@lock).to be_locked
-    end
-
-    describe "#lock" do
-      it "should not be possible" do
-        expect(@lock.lock).to be_falsey
-      end
-
-      it "should not overwrite the lock" do
-        @lock.lock
-        expect(@lock).not_to be_mine
-      end
-    end
-
-    describe "#unlock" do
-      it "should not be possible" do
-        expect(@lock.unlock).to be_falsey
-      end
-
-      it "should not remove the lock file" do
-        @lock.unlock
-        expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
-      end
-
-      it "should still not be our lock" do
-        @lock.unlock
-        expect(@lock).not_to be_mine
-      end
-    end
-  end
-
-  describe "with another process lock" do
-    before(:each) do
-      # fake our pid to be 1234
-      allow(Process).to receive(:pid).and_return(1234)
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', 1234, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-eq', 1234, '-o', 'args=']).and_return('puppet')
-      end
-      # lock the file
-      @lock.lock
-      # fake our pid to be a different pid, to simulate someone else
-      #  holding the lock
-      allow(Process).to receive(:pid).and_return(6789)
-
-      allow(Process).to receive(:kill).with(0, 6789)
-      allow(Process).to receive(:kill).with(0, 1234)
-    end
-
-    it "should be locked" do
-      expect(@lock).to be_locked
-    end
-
-    it "should not be mine" do
-      expect(@lock).not_to be_mine
-    end
-
-    it "should be locked if the other process is a puppet gem" do
-      File.write(@lockfile, "1234")
-
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('ruby')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should not be mine if the other process is a puppet gem" do
-      File.write(@lockfile, "1234")
-
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('ruby')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      end
-      expect(@lock).to_not be_mine
-    end
-
-    describe "#lock" do
-      it "should not be possible" do
-        expect(@lock.lock).to be_falsey
-      end
-
-      it "should not overwrite the lock" do
-        @lock.lock
-        expect(@lock).not_to be_mine
-      end
-    end
-
-    describe "#unlock" do
-      it "should not be possible" do
-        expect(@lock.unlock).to be_falsey
-      end
-
-      it "should not remove the lock file" do
-        @lock.unlock
-        expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
-      end
-
-      it "should still not be our lock" do
-        @lock.unlock
-        expect(@lock).not_to be_mine
-      end
-    end
-  end
-end

data/spec/unit/util/plist_spec.rb

@@ -1,168 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'puppet/util/plist'
-require 'puppet_spec/files'
-
-describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
-  include PuppetSpec::Files
-
-  let(:valid_xml_plist) do
-    '<?xml version="1.0" encoding="UTF-8"?>
-     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-     <plist version="1.0">
-     <dict>
-       <key>LastUsedPrinters</key>
-       <array>
-         <dict>
-                 <key>Network</key>
-                 <string>10.85.132.1</string>
-                 <key>PrinterID</key>
-                 <string>baskerville_corp_puppetlabs_net</string>
-         </dict>
-         <dict>
-                 <key>Network</key>
-                 <string>10.14.96.1</string>
-                 <key>PrinterID</key>
-                 <string>Statler</string>
-         </dict>
-       </array>
-    </dict>
-    </plist>'
-  end
-  let(:invalid_xml_plist) do
-    '<?xml version="1.0" encoding="UTF-8"?>
-     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-     <plist version="1.0">
-     <dict>
-       <key>LastUsedPrinters</key>
-       <array>
-         <dict>
-                 <!-- this comment is --terrible -->
-                 <key>Network</key>
-                 <string>10.85.132.1</string>
-                 <key>PrinterID</key>
-                 <string>baskerville_corp_puppetlabs_net</string>
-         </dict>
-         <dict>
-                 <key>Network</key>
-                 <string>10.14.96.1</string>
-                 <key>PrinterID</key>
-                 <string>Statler</string>
-         </dict>
-       </array>
-    </dict>
-    </plist>'
-  end
-  let(:ascii_xml_plist) do
-    '<?xml version="1.0" encoding="UTF-8"?>
-     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-     <plist version="1.0">
-     <dict>
-       <key>RecordName</key>
-         <array>
-           <string>Timișoara</string>
-           <string>Tōkyō</string>
-         </array>
-     </dict>
-     </plist>'.force_encoding(Encoding::US_ASCII)
-  end
-  let(:non_plist_data) do
-    "Take my love, take my land
-     Take me where I cannot stand
-     I don't care, I'm still free
-     You can't take the sky from me."
-  end
-  let(:binary_data) do
-    "\xCF\xFA\xED\xFE\a\u0000\u0000\u0001\u0003\u0000\u0000\x80\u0002\u0000\u0000\u0000\u0012\u0000\u0000\u0000\b"
-  end
-  let(:valid_xml_plist_hash) { {"LastUsedPrinters"=>[{"Network"=>"10.85.132.1", "PrinterID"=>"baskerville_corp_puppetlabs_net"}, {"Network"=>"10.14.96.1", "PrinterID"=>"Statler"}]} }
-  let(:ascii_xml_plist_hash) { {"RecordName"=>["Timișoara", "Tōkyō"]} }
-  let(:plist_path) { file_containing('sample.plist', valid_xml_plist) }
-  let(:binary_plist_magic_number) { 'bplist00' }
-  let(:bad_xml_doctype) { '<!DOCTYPE plist PUBLIC -//Apple Computer' }
-  let(:good_xml_doctype) { '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' }
-
-  describe "#read_plist_file" do
-    it "calls #convert_cfpropertylist_to_native_types on a plist object when a valid binary plist is read" do
-      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return(binary_plist_magic_number)
-      allow(subject).to receive(:new_cfpropertylist).with({:file => plist_path}).and_return('plist_object')
-      expect(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object').and_return('plist_hash')
-      expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
-    end
-
-    it "returns a valid hash when a valid XML plist is read" do
-      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
-      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(valid_xml_plist)
-      expect(subject.read_plist_file(plist_path)).to eq(valid_xml_plist_hash)
-    end
-
-    it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
-      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
-      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(bad_xml_doctype)
-      expect(subject).to receive(:new_cfpropertylist).with({:data => good_xml_doctype}).and_return('plist_object')
-      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object').and_return('plist_hash')
-      expect(Puppet).to receive(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
-      expect(subject.read_plist_file(plist_path)).to eq('plist_hash')
-    end
-
-    it "attempts to read pure xml using plutil when reading an improperly formatted service plist" do
-      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
-      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(invalid_xml_plist)
-      expect(Puppet).to receive(:debug).with(/^Failed with CFFormatError/)
-      expect(Puppet).to receive(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
-              {:failonfail => true, :combine => true})
-        .and_return(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
-      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
-      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(non_plist_data)
-      expect(Puppet).to receive(:debug).with(/^Failed with (CFFormatError|NoMethodError)/)
-      expect(Puppet).to receive(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
-              {:failonfail => true, :combine => true})
-        .and_raise(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
-      allow(subject).to receive(:read_file_with_offset).with(plist_path, 8).and_return('notbinary')
-      allow(subject).to receive(:open_file_with_args).with(plist_path, 'r:UTF-8').and_return(binary_data)
-      expect(Puppet).to receive(:debug).with(/^Failed with (CFFormatError|ArgumentError)/)
-      expect(Puppet).to receive(:debug).with("Plist #{plist_path} ill-formatted, converting with plutil")
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['/usr/bin/plutil', '-convert', 'xml1', '-o', '-', plist_path],
-              {:failonfail => true, :combine => true})
-        .and_raise(Puppet::ExecutionFailure, 'boom')
-      expect(subject.read_plist_file(plist_path)).to eq(nil)
-    end
-  end
-
-  describe "#parse_plist" do
-    it "returns a valid hash when a valid XML plist is provided" do
-      expect(subject.parse_plist(valid_xml_plist)).to eq(valid_xml_plist_hash)
-    end
-
-    it "returns a valid hash when an ASCII XML plist is provided" do
-      expect(subject.parse_plist(ascii_xml_plist)).to eq(ascii_xml_plist_hash)
-    end
-
-    it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
-      expect(subject).to receive(:new_cfpropertylist).with({:data => good_xml_doctype}).and_return('plist_object')
-      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object')
-      expect(Puppet).to receive(:debug).with("Had to fix plist with incorrect DOCTYPE declaration: #{plist_path}")
-      subject.parse_plist(bad_xml_doctype, plist_path)
-    end
-
-    it "raises a debug message with malformed plist" do
-      allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object')
-      expect(Puppet).to receive(:debug).with(/^Failed with CFFormatError/)
-      subject.parse_plist("<plist><dict><key>Foo</key>")
-    end
-  end
-end