puppet 7.3.0-x86-mingw32 → 7.7.0-x86-mingw32

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

@@ -4,16 +4,6 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
   let (:resource) { Puppet::Resource.new(:package, 'dummy', :parameters => {:name => 'dummy', :ensure => :latest}) }
   let (:provider) { described_class.new(resource) }
 
-  before(:all) do
-    if Puppet::Util::Platform.windows?
-      # Get a pid for $CHILD_STATUS to latch on to
-      command = "cmd.exe /c \"exit 0\""
-      Puppet::Util::Execution.execute(command, {:failonfail => false})
-    else
-      Puppet::Util::Execution.execute('exit 0', {:failonfail => false})
-    end
-  end
-
   before :each do
     allow(described_class).to receive(:command).with(:pkg).and_return('/bin/pkg')
   end
@@ -120,7 +110,6 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         expect(Puppet::Util::Execution).to receive(:execute)
           .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
           .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
 
         expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.known')))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
@@ -132,8 +121,9 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
       end
 
       it "should work correctly for ensure latest on solaris 11(known IFO)" do
-        expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).and_return('')
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(Puppet::Util::Execution).to receive(:execute)
+          .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
         expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.ifo.known')))
         expect(provider.latest).to eq('1.0.6,5.11-0.175.0.0.0.2.537:20131230T130000Z')
@@ -158,7 +148,8 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         resource[:install_options] = ['--foo', {'--bar' => 'baz'}]
         expect(described_class).to receive(:pkg).with(:list,'-Hvn','dummy').and_return(File.read(my_fixture('dummy_solaris11.known')))
         expect(Puppet::Util::Execution).to receive(:execute)
-            .with(['/bin/pkg', 'update', '-n', '--foo', '--bar=baz', 'dummy'], {failonfail: false, combine: true})
+          .with(['/bin/pkg', 'update', '-n', '--foo', '--bar=baz', 'dummy'], {failonfail: false, combine: true})
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
         provider.latest
       end
     end
@@ -195,7 +186,6 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
           expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
             .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
           expect(provider.query).to eq({
             :name      => 'dummy',
             :ensure    => '2.5.5,5.10-0.111:20131230T130000Z',
@@ -208,15 +198,13 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         it "should return :absent when the package is not found" do
           expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 1))
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
 
       context "on solaris 11" do
         it "should find the package" do
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
           expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
             .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
@@ -232,8 +220,7 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         it "should return :absent when the package is not found" do
           expect(Puppet::Util::Execution).to receive(:execute)
             .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
-            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', 1))
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
@@ -242,7 +229,6 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
         expect(Puppet::Util::Execution).to receive(:execute)
           .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
           .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
         expect {
           provider.query
         }.to raise_error(ArgumentError, /Unknown line format/)
@@ -266,7 +252,7 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(provider).to receive(:unhold)
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], '--foo', '--bar=baz', 'dummy'], {:failonfail => false, :combine => true})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
@@ -279,16 +265,16 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
           it "should install specific version(1)" do
             # Should install also check if the version installed is the same version we are asked to install? or should we rely on puppet for that?
             resource[:ensure] = '0.0.7,5.11-0.151006:20131230T130000Z'
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             expect(provider).to receive(:properties).and_return({:mark => :hold})
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----', 0))
@@ -301,14 +287,15 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
           it "should install specific version(2)" do
             resource[:ensure] = '0.0.8'
             expect(provider).to receive(:properties).and_return({:mark => :hold})
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----', 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
@@ -316,8 +303,9 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             resource[:ensure] = '0.0.7'
             expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
@@ -331,8 +319,9 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
@@ -340,11 +329,12 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             resource[:ensure] = '0.0.7'
             expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => :absent})
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             expect(Puppet::Util::Execution).to receive(:execute)
               .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
               .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.install
           end
 
@@ -356,10 +346,13 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             expect(provider).to receive(:unhold).with(no_args)
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.insync?(is)
             provider.install
           end
@@ -370,10 +363,13 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
             expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             expect(provider).to receive(:unhold).with(no_args)
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.insync?(is)
             provider.install
           end
@@ -385,8 +381,9 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(4)
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 4))
             provider.insync?(is)
           end
 
@@ -395,9 +392,12 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             is = :absent
             expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
             expect(provider).to receive(:warning).with("Selecting version '1.0,5.11-0.151006:20140220T084443Z' for implicit '1.0-0.151006'")
-            expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
-            expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+            expect(described_class).to receive(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
+            expect(Puppet::Util::Execution).to receive(:execute)
+              .with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
+              .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.insync?(is)
           end
         end

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

@@ -31,6 +31,34 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
     allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
   end
 
+
+  describe '.windows_gemcmd' do
+    context 'when PUPPET_DIR is not set' do
+      before do
+        allow(Puppet::Util).to receive(:get_env).and_call_original
+        allow(Puppet::Util).to receive(:get_env).with('PUPPET_DIR').and_return(nil)
+        allow(Gem).to receive(:default_bindir).and_return('default_gem_bin')
+      end
+
+      it 'uses Gem.default_bindir' do
+        expected_path = File.join('default_gem_bin', 'gem.bat')
+        expect(described_class.windows_gemcmd).to eql(expected_path)
+      end
+    end
+
+    context 'when PUPPET_DIR is set' do
+      before do
+        allow(Puppet::Util).to receive(:get_env).and_call_original
+        allow(Puppet::Util).to receive(:get_env).with('PUPPET_DIR').and_return('puppet_dir')
+      end
+
+      it 'uses Gem.default_bindir' do
+        expected_path = File.join('puppet_dir', 'bin', 'gem.bat')
+        expect(described_class.windows_gemcmd).to eql(expected_path)
+      end
+    end
+  end
+
   context "when installing" do
     before :each do
       allow(provider).to receive(:rubygem_version).and_return('1.9.9')
@@ -82,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/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/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