puppet 7.6.1-universal-darwin → 7.10.0-universal-darwin

data/spec/unit/provider/package/puppet_gem_spec.rb

@@ -110,13 +110,15 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
   end
 
   context 'calculated specificity' do
+    include_context 'provider specificity'
+
     context 'when is not defaultfor' do
       subject { described_class.specificity }
       it { is_expected.to eql 1 }
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Facter.value(:operatingsystem) }
+      let(:os) { Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/package/puppetserver_gem_spec.rb

@@ -119,6 +119,8 @@ describe Puppet::Type.type(:package).provider(:puppetserver_gem) do
   end
 
   context 'calculated specificity' do
+    include_context 'provider specificity'
+
     context 'when is not defaultfor' do
       subject { described_class.specificity }
       it { is_expected.to eql 1 }

data/spec/unit/provider/package/windows/exe_package_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet/provider/package/windows/exe_package'
+require 'puppet/provider/package/windows'
 
 describe Puppet::Provider::Package::Windows::ExePackage do
   let (:name)        { 'Git version 1.7.11' }
@@ -71,10 +72,26 @@ describe Puppet::Provider::Package::Windows::ExePackage do
 
   context '#install_command' do
     it 'should install using the source' do
+      allow(Puppet::FileSystem).to receive(:exist?).with(source).and_return(true)
       cmd = described_class.install_command({:source => source})
 
       expect(cmd).to eq(source)
     end
+
+    it 'should raise error when URI is invalid' do
+      web_source = 'https://www.t e s t.test/test.exe'
+
+      expect do
+        described_class.install_command({:source => web_source, :name => name})
+      end.to raise_error(Puppet::Error, /Error when installing #{name}:/)
+    end
+
+    it 'should download package from source file before installing', if: Puppet::Util::Platform.windows? do
+      web_source = 'https://www.test.test/test.exe'
+      stub_request(:get, web_source).to_return(status: 200, body: 'package binaries')
+      cmd = described_class.install_command({:source => web_source})
+      expect(File.read(cmd)).to eq('package binaries')
+    end
   end
 
   context '#uninstall_command' do

data/spec/unit/provider/parsedfile_spec.rb

@@ -79,6 +79,16 @@ describe Puppet::Provider::ParsedFile do
 
       provider.instances
     end
+
+    it "should raise if parsing returns nil" do
+      expect(provider).to receive(:targets).and_return(%w{/one})
+      expect_any_instance_of(Puppet::Util::FileType::FileTypeFlat).to receive(:read).and_return('a=b')
+      expect(provider).to receive(:parse).and_return(nil)
+
+      expect {
+        provider.instances
+      }.to raise_error(Puppet::DevError, %r{Prefetching /one for provider parsedfile_provider returned nil})
+    end
   end
 
   describe "when matching resources to existing records" do

data/spec/unit/provider/service/base_spec.rb

@@ -14,10 +14,6 @@ describe "base service provider" do
 
   subject { provider }
 
-  before(:all) do
-    `exit 0`
-  end
-
   context "basic operations" do
     subject do
       type.new(
@@ -35,16 +31,19 @@ describe "base service provider" do
         expect(options[:failonfail]).to eq(true)
         raise(Puppet::ExecutionFailure, 'failed to start') if @running
         @running = true
-        return 'started'
+        Puppet::Util::Execution::ProcessOutput.new('started', 0)
       when status_command
         expect(options[:failonfail]).to eq(false)
-        allow($CHILD_STATUS).to receive(:exitstatus) {@running ? 0 : 1}
-        return @running ? 'running' : 'not running'
+        if @running
+          Puppet::Util::Execution::ProcessOutput.new('running', 0)
+        else
+          Puppet::Util::Execution::ProcessOutput.new('not running', 1)
+        end
       when stop_command
         expect(options[:failonfail]).to eq(true)
         raise(Puppet::ExecutionFailure, 'failed to stop') unless @running
         @running = false
-        return 'stopped'
+        Puppet::Util::Execution::ProcessOutput.new('stopped', 0)
       else
         raise "unexpected command execution: #{command}"
       end
@@ -98,6 +97,7 @@ describe "base service provider" do
     end
 
     it "retrieves a PID from the process table" do
+      allow(Facter).to receive(:value).and_call_original
       allow(Facter).to receive(:value).with(:operatingsystem).and_return("CentOS")
       ps_output = File.binread(my_fixture("ps_ef.mixed_encoding")).force_encoding(Encoding::UTF_8)
 

data/spec/unit/provider/service/bsd_spec.rb

@@ -4,10 +4,6 @@ describe 'Puppet::Type::Service::Provider::Bsd',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:bsd) }
 
-  before(:all) do
-    `exit 0`
-  end
-
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
     allow(Facter).to receive(:value).with(:operatingsystem).and_return(:netbsd)

data/spec/unit/provider/service/daemontools_spec.rb

@@ -109,7 +109,7 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
       path = File.join(@servicedir,"myservice")
       expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(true)
       expect(Puppet::FileSystem).to receive(:unlink).with(path)
-      allow(@provider).to receive(:texecute).and_return("")
+      allow(@provider).to receive(:execute).and_return("")
       @provider.disable
     end
 

data/spec/unit/provider/service/debian_spec.rb

@@ -4,10 +4,6 @@ describe 'Puppet::Type::Service::Provider::Debian',
          unless: Puppet::Util::Platform.jruby? || Puppet::Util::Platform.windows? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:debian) }
 
-  before(:all) do
-    `exit 0`
-  end
-
   before(:each) do
     # Create a mock resource
     @resource = double('resource')
@@ -90,34 +86,37 @@ describe 'Puppet::Type::Service::Provider::Debian',
   end
 
   context "when checking whether it is enabled" do
-    it "should call Kernel.system() with the appropriate parameters" do
-      expect(@provider).to receive(:system).with("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start").once
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+    it "should execute the query command" do
+      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start"], :failonfail => false)
+                             .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       @provider.enabled?
     end
 
     it "should return true when invoke-rc.d exits with 104 status" do
-      allow(@provider).to receive(:system)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(104)
+      expect(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', 104))
       expect(@provider.enabled?).to eq(:true)
     end
 
     it "should return true when invoke-rc.d exits with 106 status" do
-      allow(@provider).to receive(:system)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(106)
+      expect(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', 106))
       expect(@provider.enabled?).to eq(:true)
     end
 
+    it "should consider nonexistent services to be disabled" do
+      @provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'doesnotexist'))
+      expect(@provider).to receive(:execute).with(["/usr/sbin/invoke-rc.d", "--quiet", "--query", "doesnotexist", "start"], :failonfail => false)
+                             .and_return(Puppet::Util::Execution::ProcessOutput.new("", 1))
+      expect(@provider.enabled?).to be(:false)
+    end
+
     shared_examples "manually queries service status" do |status|
       it "links count is 4" do
-        allow(@provider).to receive(:system)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(status)
+        allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
         allow(@provider).to receive(:get_start_link_count).and_return(4)
         expect(@provider.enabled?).to eq(:true)
       end
       it "links count is less than 4" do
-        allow(@provider).to receive(:system)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(status)
+        allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
         allow(@provider).to receive(:get_start_link_count).and_return(3)
         expect(@provider.enabled?).to eq(:false)
       end
@@ -142,8 +141,7 @@ describe 'Puppet::Type::Service::Provider::Debian',
     # pick a range of non-[104.106] numbers, strings and booleans to test with.
     [-100, -1, 0, 1, 100, "foo", "", :true, :false].each do |exitstatus|
       it "should return false when invoke-rc.d exits with #{exitstatus} status" do
-        allow(@provider).to receive(:system)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(exitstatus)
+        allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', exitstatus))
         expect(@provider.enabled?).to eq(:false)
       end
     end

data/spec/unit/provider/service/freebsd_spec.rb

@@ -82,7 +82,7 @@ OUTPUT
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf').and_return(true)
     allow(File).to receive(:read).with('/etc/rc.conf').and_return("openntpd_enable=\"NO\"\nntpd_enable=\"NO\"\n")
     fh = double('fh')
-    allow(File).to receive(:open).with('/etc/rc.conf', File::WRONLY).and_yield(fh)
+    allow(Puppet::FileSystem).to receive(:replace_file).with('/etc/rc.conf').and_yield(fh)
     expect(fh).to receive(:<<).with("openntpd_enable=\"NO\"\nntpd_enable=\"YES\"\n")
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.local').and_return(false)
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/ntpd').and_return(false)

data/spec/unit/provider/service/gentoo_spec.rb

@@ -4,10 +4,6 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:gentoo) }
 
-  before(:all) do
-    `exit 0`
-  end
-
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
     allow(FileTest).to receive(:file?).with('/sbin/rc-update').and_return(true)
@@ -46,6 +42,10 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
     ]
   end
 
+  let :process_output do
+    Puppet::Util::Execution::ProcessOutput.new('', 0)
+  end
+
   describe ".instances" do
     it "should have an instances method" do
       expect(provider_class).to respond_to(:instances)
@@ -160,24 +160,27 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
       it "should use the status command from the resource" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(provider).to receive(:execute)
+          .with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(process_output)
         provider.status
       end
 
       it "should return :stopped when the status command returns with a non-zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(3)
+        expect(provider).to receive(:execute)
+          .with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 3))
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running when the status command returns with a zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
         expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(provider).to receive(:execute)
+          .with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(process_output)
         expect(provider.status).to eq(:running)
       end
     end
@@ -202,16 +205,18 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
       it "should return running if <initscript> status exits with a zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
         expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-        expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(provider).to receive(:execute)
+          .with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(process_output)
         expect(provider.status).to eq(:running)
       end
 
       it "should return stopped if <initscript> status exits with a non-zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
         expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-        expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(3)
+        expect(provider).to receive(:execute)
+          .with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 3))
         expect(provider.status).to eq(:stopped)
       end
     end

data/spec/unit/provider/service/init_spec.rb

@@ -4,10 +4,6 @@ describe 'Puppet::Type::Service::Provider::Init',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:init) }
 
-  before :all do
-    `exit 0`
-  end
-
   before do
     Puppet::Type.type(:service).defaultprovider = provider_class
   end
@@ -37,6 +33,10 @@ describe 'Puppet::Type::Service::Provider::Init',
     %w{functions.sh reboot.sh shutdown.sh functions halt killall single linuxconf reboot boot wait-for-state rcS module-init-tools}
   end
 
+  let :process_output do
+    Puppet::Util::Execution::ProcessOutput.new('', 0)
+  end
+
   describe "when running on FreeBSD" do
     before :each do
       allow(Facter).to receive(:value).with(:operatingsystem).and_return('FreeBSD')
@@ -83,6 +83,7 @@ describe 'Puppet::Type::Service::Provider::Init',
       allow(provider_class).to receive(:defpath).and_return('tmp')
 
       @services = ['one', 'two', 'three', 'four', 'umountfs']
+      allow(Dir).to receive(:entries).and_call_original
       allow(Dir).to receive(:entries).with('tmp').and_return(@services)
       expect(FileTest).to receive(:directory?).with('tmp').and_return(true)
       allow(FileTest).to receive(:executable?).and_return(true)
@@ -203,12 +204,12 @@ describe 'Puppet::Type::Service::Provider::Init',
 
       describe "when running #{method}" do
         before :each do
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          allow(provider).to receive(:execute).and_return(process_output)
         end
 
         it "should use any provided explicit command" do
           resource[method] = "/user/specified/command"
-          expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
+          expect(provider).to receive(:execute).with(["/user/specified/command"], any_args).and_return(process_output)
 
           provider.send(method)
         end
@@ -216,7 +217,7 @@ describe 'Puppet::Type::Service::Provider::Init',
         it "should pass #{method} to the init script when no explicit command is provided" do
           resource[:hasrestart] = :true
           resource[:hasstatus] = :true
-          expect(provider).to receive(:execute).with(["/service/path/myservice", method], any_args)
+          expect(provider).to receive(:execute).with(["/service/path/myservice", method], any_args).and_return(process_output)
 
           provider.send(method)
         end
@@ -230,21 +231,24 @@ describe 'Puppet::Type::Service::Provider::Init',
         end
 
         it "should execute the command" do
-          expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          expect(provider).to receive(:execute)
+            .with(['/service/path/myservice', :status], hash_including(failonfail: false))
+            .and_return(process_output)
           provider.status
         end
 
         it "should consider the process running if the command returns 0" do
-          expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          expect(provider).to receive(:execute)
+            .with(['/service/path/myservice', :status], hash_including(failonfail: false))
+            .and_return(process_output)
           expect(provider.status).to eq(:running)
         end
 
         [-10,-1,1,10].each { |ec|
           it "should consider the process stopped if the command returns something non-0" do
-            expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+            expect(provider).to receive(:execute)
+              .with(['/service/path/myservice', :status], hash_including(failonfail: false))
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', ec))
             expect(provider.status).to eq(:stopped)
           end
         }
@@ -273,9 +277,12 @@ describe 'Puppet::Type::Service::Provider::Init',
       end
 
       it "should stop and restart the process" do
-        expect(provider).to receive(:texecute).with(:stop,  ['/service/path/myservice', :stop ], true).and_return("")
-        expect(provider).to receive(:texecute).with(:start, ['/service/path/myservice', :start], true).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(provider).to receive(:execute)
+          .with(['/service/path/myservice', :stop], hash_including(failonfail: true))
+          .and_return(process_output)
+        expect(provider).to receive(:execute)
+          .with(['/service/path/myservice', :start], hash_including(failonfail: true))
+          .and_return(process_output)
         provider.restart
       end
     end
@@ -283,8 +290,9 @@ describe 'Puppet::Type::Service::Provider::Init',
     describe "when starting a service on Solaris" do
       it "should use ctrun" do
         allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-        expect(provider).to receive(:execute).with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(provider).to receive(:execute)
+          .with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+          .and_return(process_output)
         provider.start
       end
     end
@@ -292,8 +300,9 @@ describe 'Puppet::Type::Service::Provider::Init',
     describe "when starting a service on RedHat" do
       it "should not use ctrun" do
         allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-        expect(provider).to receive(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(provider).to receive(:execute)
+          .with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true})
+          .and_return(process_output)
         provider.start
       end
     end

data/spec/unit/provider/service/launchd_spec.rb

@@ -12,8 +12,8 @@ describe 'Puppet::Type::Service::Provider::Launchd',
 
   subject { resource.provider }
 
-  before :all do
-    `exit 0`
+  after :each do
+    provider.instance_variable_set(:@job_list, nil)
   end
 
   describe "the type interface" do
@@ -41,10 +41,6 @@ describe 'Puppet::Type::Service::Provider::Launchd',
       expect(provider.prefetch({}).last.status).to eq(:running)
     end
 
-    after :each do
-      provider.instance_variable_set(:@job_list, nil)
-    end
-
     describe "when hasstatus is set to false" do
       before :each do
         resource[:hasstatus] = :false
@@ -52,15 +48,17 @@ describe 'Puppet::Type::Service::Provider::Launchd',
 
       it "should use the user-provided status command if present and return running if true" do
         resource[:status] = '/bin/true'
-        expect(subject).to receive(:texecute).with(:status, ["/bin/true"], false).and_return(0)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(subject).to receive(:execute)
+          .with(["/bin/true"], hash_including(failonfail: false))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
         expect(subject.status).to eq(:running)
       end
 
       it "should use the user-provided status command if present and return stopped if false" do
         resource[:status] = '/bin/false'
-        expect(subject).to receive(:texecute).with(:status, ["/bin/false"], false).and_return(nil)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+        expect(subject).to receive(:execute)
+          .with(["/bin/false"], hash_including(failonfail: false))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 1))
         expect(subject.status).to eq(:stopped)
       end
 
@@ -130,7 +128,7 @@ describe 'Puppet::Type::Service::Provider::Launchd',
 
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
-      expect(subject).to receive(:texecute).with(:start, ["/bin/false"], true)
+      expect(subject).to receive(:execute).with(["/bin/false"], hash_including(failonfail: true))
       subject.start
     end
 
@@ -184,7 +182,7 @@ describe 'Puppet::Type::Service::Provider::Launchd',
   describe "when stopping the service" do
     it "should call any explicit 'stop' command" do
       resource[:stop] = "/bin/false"
-      expect(subject).to receive(:texecute).with(:stop, ["/bin/false"], true)
+      expect(subject).to receive(:execute).with(["/bin/false"], hash_including(failonfail: true))
       subject.stop
     end
 
@@ -327,6 +325,7 @@ describe 'Puppet::Type::Service::Provider::Launchd',
           'LimitLoadToSessionType' => 'Aqua'
         }
       end
+      let(:plist_without_label_not_hash) { 'just a string' }
       let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
       let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
@@ -338,6 +337,16 @@ describe 'Puppet::Type::Service::Provider::Launchd',
         expect(Puppet).to receive(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
+
+      it "it should warn that the malformed plist in question is being skipped" do
+        expect(provider).to receive(:launchd_paths).and_return(['/Library/LaunchAgents'])
+        expect(provider).to receive(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').and_return([busted_plist_path])
+        expect(plistlib).to receive(:read_plist_file).with(busted_plist_path).and_return(plist_without_label_not_hash)
+        expect(Puppet).to receive(:debug).with("Reading launchd plist #{busted_plist_path}")
+        expect(Puppet).to receive(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
+        provider.make_label_to_path_map
+      end
+
     end
 
     it "should return the cached value when available" do