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

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

@@ -12,15 +12,6 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
     allow(FileTest).to receive(:executable?).with('/usr/sbin/rcctl').and_return(true)
   end
 
-  # `execute` and `texecute` start a new process, consequently setting $CHILD_STATUS to a Process::Status instance,
-  # but because they are mocked, an external process is never executed and $CHILD_STATUS remain nil.
-  # In order to execute some parts of the code under test and to mock $CHILD_STATUS, we need this variable to be a
-  # Process::Status instance. We can achieve this by starting a process that does nothing (exit 0). By doing this,
-  # $CHILD_STATUS will be initialised with a instance of Process::Status and we will be able to mock it.
-  before(:all) do
-    `exit 0`
-  end
-
   context "#instances" do
     it "should have an instances method" do
       expect(provider_class).to respond_to :instances
@@ -43,7 +34,7 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
 
     it "should start the service otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', '-f', :start, 'sshd'], hash_including(failonfail: true))
       provider.start
     end
   end
@@ -57,7 +48,7 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
 
     it "should stop the service otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', :stop, 'sshd'], hash_including(failonfail: true))
       provider.stop
     end
   end
@@ -66,23 +57,27 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
     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(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/bin/foo'], :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)
+       .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       provider.status
     end
 
     it "should return :stopped when 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(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :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 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(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :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(Puppet::Util::Execution::ProcessOutput.new('', 0))
       expect(provider.status).to eq(:running)
     end
   end
@@ -91,21 +86,23 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
     it "should use the supplied restart command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
       expect(provider).not_to receive(:execute).with(['/usr/sbin/rcctl', '-f', :restart, 'sshd'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      expect(provider).to receive(:execute)
+        .with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       provider.restart
     end
 
     it "should restart the service with rcctl restart if hasrestart is true" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      expect(provider).to receive(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], true)
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', '-f', :restart, 'sshd'], hash_including(failonfail: true))
       provider.restart
     end
 
     it "should restart the service with rcctl stop/start if hasrestart is false" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      expect(provider).not_to receive(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], true)
-      expect(provider).to receive(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
-      expect(provider).to receive(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
+      expect(provider).not_to receive(:execute).with(['/usr/sbin/rcctl', '-f', :restart, 'sshd'], any_args)
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', :stop, 'sshd'], hash_including(failonfail: true))
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', '-f', :start, 'sshd'], hash_including(failonfail: true))
       provider.restart
     end
   end
@@ -113,15 +110,13 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:get, 'sshd', :status)
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).and_return(double(:exitstatus => 0))
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :false if the service is disabled" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:get, 'sshd', :status).and_return('NO')
-      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).and_return(double(:exitstatus => 1))
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).and_return(Puppet::Util::Execution::ProcessOutput.new('NO', 1))
       expect(provider.enabled?).to eq(:false)
     end
   end
@@ -129,15 +124,12 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#enable" do
     it "should run rcctl enable to enable the service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:enable, 'sshd').and_return('')
       expect(provider).to receive(:rcctl).with(:enable, 'sshd')
       provider.enable
     end
 
     it "should run rcctl enable with flags if provided" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :flags => '-6'))
-      allow(provider_class).to receive(:rcctl).with(:enable, 'sshd').and_return('')
-      allow(provider_class).to receive(:rcctl).with(:set, 'sshd', :flags, '-6').and_return('')
       expect(provider).to receive(:rcctl).with(:enable, 'sshd')
       expect(provider).to receive(:rcctl).with(:set, 'sshd', :flags, '-6')
       provider.enable
@@ -147,7 +139,6 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#disable" do
     it "should run rcctl disable to disable the service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:disable, 'sshd').and_return('')
       expect(provider).to receive(:rcctl).with(:disable, 'sshd')
       provider.disable
     end
@@ -156,21 +147,18 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#running?" do
     it "should run rcctl check to check the service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:check, 'sshd').and_return('sshd(ok)')
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).and_return('sshd(ok)')
       expect(provider.running?).to be_truthy
     end
 
     it "should return true if the service is running" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:check, 'sshd').and_return('sshd(ok)')
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).and_return('sshd(ok)')
       expect(provider.running?).to be_truthy
     end
 
     it "should return nil if the service is not running" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:check, 'sshd').and_return('sshd(failed)')
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).and_return('sshd(failed)')
       expect(provider.running?).to be_nil
     end
@@ -179,21 +167,18 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#flags" do
     it "should return flags when set" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :flags => '-6'))
-      allow(provider_class).to receive(:rcctl).with('get', 'sshd', 'flags').and_return('-6')
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], :failonfail => false, :combine => false, :squelch => false).and_return('-6')
       provider.flags
     end
 
     it "should return empty flags" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with('get', 'sshd', 'flags').and_return('')
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], :failonfail => false, :combine => false, :squelch => false).and_return('')
       provider.flags
     end
 
     it "should return flags for special services" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'pf'))
-      allow(provider_class).to receive(:rcctl).with('get', 'pf', 'flags').and_return('YES')
       expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'pf', 'flags'], :failonfail => false, :combine => false, :squelch => false).and_return('YES')
       provider.flags
     end
@@ -202,8 +187,9 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#flags=" do
     it "should run rcctl to set flags", unless: Puppet::Util::Platform.windows? || RUBY_PLATFORM == 'java' do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(provider_class).to receive(:rcctl).with(:set, 'sshd', :flags, '-4').and_return('')
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], any_args).and_return('')
       expect(provider).to receive(:rcctl).with(:set, 'sshd', :flags, '-4')
+      expect(provider).to receive(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], any_args).and_return('')
       provider.flags = '-4'
     end
   end

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

@@ -4,10 +4,6 @@ describe 'Puppet::Type::Service::Provider::Openrc',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:openrc) }
 
-  before :all do
-    `exit 0`
-  end
-
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
     ['/sbin/rc-service', '/bin/rc-status', '/sbin/rc-update'].each do |command|
@@ -150,24 +146,27 @@ describe 'Puppet::Type::Service::Provider::Openrc',
       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(['/sbin/rc-service','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(Puppet::Util::Execution::ProcessOutput.new('', 0))
         provider.status
       end
 
       it "should return :stopped when 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(['/sbin/rc-service','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 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(['/sbin/rc-service','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(Puppet::Util::Execution::ProcessOutput.new('', 0))
         expect(provider.status).to eq(:running)
       end
     end
@@ -191,15 +190,17 @@ describe 'Puppet::Type::Service::Provider::Openrc',
     describe "when hasstatus is true" do
       it "should return running if rc-service status exits with a zero exitcode" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        expect(provider).to receive(:execute).with(['/sbin/rc-service','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(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
         expect(provider.status).to eq(:running)
       end
 
       it "should return stopped if rc-service 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(:execute).with(['/sbin/rc-service','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(['/sbin/rc-service','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/openwrt_spec.rb

@@ -32,6 +32,7 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
     allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
 
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:file?).and_call_original
     allow(FileTest).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
     allow(FileTest).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
   end
@@ -47,7 +48,8 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
     let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
 
     before :each do
-      allow(Dir).to receive(:entries).and_return(services)
+      allow(Dir).to receive(:entries).and_call_original
+      allow(Dir).to receive(:entries).with('/etc/init.d').and_return(services)
       allow(FileTest).to receive(:directory?).and_return(true)
       allow(FileTest).to receive(:executable?).and_return(true)
     end

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

@@ -4,15 +4,6 @@ describe 'Puppet::Type::Service::Provider::Redhat',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:redhat) }
 
-  # `execute` and `texecute` start a new process, consequently setting $CHILD_STATUS to a Process::Status instance,
-  # but because they are mocked, an external process is never executed and $CHILD_STATUS remain nil.
-  # In order to execute some parts of the code under test and to mock $CHILD_STATUS, we need this variable to be a
-  # Process::Status instance. We can achieve this by starting a process that does nothing (exit 0). By doing this,
-  # $CHILD_STATUS will be initialised with a instance of Process::Status and we will be able to mock it.
-  before(:all) do
-    `exit 0`
-  end
-
   before :each do
     @class = Puppet::Type.type(:service).provider(:redhat)
     @resource = double('resource')
@@ -65,7 +56,9 @@ describe 'Puppet::Type::Service::Provider::Redhat',
     it "should call service status when initialized from provider" do
       allow(@resource).to receive(:[]).with(:status).and_return(nil)
       allow(@provider).to receive(:get).with(:hasstatus).and_return(true)
-      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'status'], any_args)
+      expect(@provider).to receive(:execute)
+        .with(['/sbin/service', 'myservice', 'status'], any_args)
+        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       @provider.send(:status)
     end
   end
@@ -127,13 +120,17 @@ describe 'Puppet::Type::Service::Provider::Redhat',
     describe "when running #{method}" do
       it "should use any provided explicit command" do
         allow(@resource).to receive(:[]).with(method).and_return("/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(Puppet::Util::Execution::ProcessOutput.new('', 0))
         @provider.send(method)
       end
 
       it "should execute the service script with #{method} when no explicit command is provided" do
         allow(@resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
-        expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', method.to_s], any_args)
+        expect(@provider).to receive(:execute)
+          .with(['/sbin/service', 'myservice', method.to_s], any_args)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
         @provider.send(method)
       end
     end
@@ -146,20 +143,24 @@ describe 'Puppet::Type::Service::Provider::Redhat',
       end
 
       it "should execute the service script with fail_on_failure false" do
-        expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+        expect(@provider).to receive(:execute)
+          .with(['/sbin/service', 'myservice', 'status'], any_args)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
         @provider.status
       end
 
       it "should consider the process running if the command returns 0" do
-        expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        expect(@provider).to receive(:execute)
+          .with(['/sbin/service', 'myservice', 'status'], hash_including(failonfail: false))
+          .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
         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, ['/sbin/service', 'myservice', 'status'], false)
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+          expect(@provider).to receive(:execute)
+            .with(['/sbin/service', 'myservice', 'status'], hash_including(failonfail: false))
+            .and_return(Puppet::Util::Execution::ProcessOutput.new('', ec))
           expect(@provider.status).to eq(:stopped)
         end
       }
@@ -180,8 +181,8 @@ describe 'Puppet::Type::Service::Provider::Redhat',
 
   context "when restarting and hasrestart is not :true" do
     it "should stop and restart the process with the server script" do
-      expect(@provider).to receive(:texecute).with(:stop,  ['/sbin/service', 'myservice', 'stop'],  true)
-      expect(@provider).to receive(:texecute).with(:start, ['/sbin/service', 'myservice', 'start'], true)
+      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'stop'], hash_including(failonfail: true))
+      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'start'], hash_including(failonfail: true))
       @provider.restart
     end
   end

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

@@ -255,12 +255,12 @@ describe 'Puppet::Type::Service::Provider::Smf',
 
     before(:each) do
       allow(@provider).to receive(:service_fmri).and_return(fmri)
-      allow(@provider).to receive(:texecute)
+      allow(@provider).to receive(:execute)
       allow(@provider).to receive(:wait)
     end
 
     it 'should restart the service' do
-      expect(@provider).to receive(:texecute)
+      expect(@provider).to receive(:execute)
       @provider.restart
     end
 
@@ -286,9 +286,9 @@ describe 'Puppet::Type::Service::Provider::Smf',
 
     it "should run the status command if it's passed in" do
       set_resource_params({ :status => 'status_cmd' })
-      expect(@provider).to receive(:ucommand).with(:status, false) do |_, _|
-        expect($CHILD_STATUS).to receive(:exitstatus).and_return(0)
-      end
+      expect(@provider).to receive(:execute)
+        .with(["status_cmd"], hash_including(failonfail: false))
+        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       expect(@provider).not_to receive(:service_states)
 
       expect(@provider.status).to eql(:running)
@@ -338,6 +338,7 @@ describe 'Puppet::Type::Service::Provider::Smf',
     it "should return stopped for an incomplete service on Solaris 11" do
       allow(Facter).to receive(:value).with(:operatingsystemrelease).and_return('11.3')
       allow(@provider).to receive(:complete_service?).and_return(false)
+      allow(@provider).to receive(:svcs).with('-l', @provider.resource[:name]).and_return(File.read(my_fixture('svcs_fmri.out')))
       expect(@provider.status).to eq(:stopped)
     end
   end

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

@@ -4,10 +4,6 @@ describe 'Puppet::Type::Service::Provider::Src',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
   let(:provider_class) { Puppet::Type.type(:service).provider(:src) }
 
-  before :all do
-    `exit 0`
-  end
-
   before :each do
     @resource = double('resource')
     allow(@resource).to receive(:[]).and_return(nil)
@@ -110,20 +106,19 @@ _EOF_
 
   context "when checking if it is enabled" do
     it "should execute the lsitab command" do
-      expect(@provider).to receive(:execute).with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      expect(@provider).to receive(:execute)
+        .with(['/usr/sbin/lsitab', 'myservice'], {:combine => true, :failonfail => false})
+        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       @provider.enabled?
     end
 
     it "should return false when lsitab returns non-zero" do
-      allow(@provider).to receive(:execute)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+      expect(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', 1))
       expect(@provider.enabled?).to eq(:false)
     end
 
     it "should return true when lsitab returns zero" do
-      allow(@provider).to receive(:execute)
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      allow(@provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
       expect(@provider.enabled?).to eq(:true)
     end
   end

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

@@ -10,19 +10,14 @@ describe 'Puppet::Type::Service::Provider::Systemd',
     allow(provider_class).to receive(:which).with('systemctl').and_return('/bin/systemctl')
   end
 
-  # `execute` and `texecute` start a new process, consequently setting $CHILD_STATUS to a Process::Status instance,
-  # but because they are mocked, an external process is never executed and $CHILD_STATUS remain nil.
-  # In order to execute some parts of the code under test and to mock $CHILD_STATUS, we need this variable to be a
-  # Process::Status instance. We can achieve this by starting a process that does nothing (exit 0). By doing this,
-  # $CHILD_STATUS will be initialised with a instance of Process::Status and we will be able to mock it.
-  before(:all) do
-    `exit 0`
-  end
-
   let :provider do
     provider_class.new(:name => 'sshd.service')
   end
 
+  let :process_output do
+    Puppet::Util::Execution::ProcessOutput.new('', 0)
+  end
+
   osfamilies = [ 'archlinux', 'coreos' ]
 
   osfamilies.each do |osfamily|
@@ -34,7 +29,7 @@ describe 'Puppet::Type::Service::Provider::Systemd',
     end
   end
 
-  [7, 8].each do |ver|
+  [7, 8, 9].each do |ver|
     it "should be the default provider on rhel#{ver}" do
       allow(Facter).to receive(:value).with(:osfamily).and_return(:redhat)
       allow(Facter).to receive(:value).with(:operatingsystem).and_return(:redhat)
@@ -335,6 +330,16 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
                             and_return(Puppet::Util::Execution::ProcessOutput.new("masked\n", 1))
       expect(provider.enabled?).to eq(:mask)
     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(['/bin/systemctl','is-enabled', '--', 'doesnotexist'], :failonfail => false)
+                            .and_return(Puppet::Util::Execution::ProcessOutput.new("", 1))
+      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
   end
 
   describe "#enable" do
@@ -357,6 +362,9 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
   describe "#mask" do
     it "should run systemctl to disable and mask a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      expect(provider).to receive(:execute).
+                            with(['/bin/systemctl','cat', '--', 'sshd.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("# /lib/systemd/system/sshd.service\n...", 0))
       # :disable is the only call in the provider that uses a symbol instead of
       # a string.
       # This should be made consistent in the future and all tests updated.
@@ -364,30 +372,43 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
       expect(provider).to receive(:systemctl).with(:mask, '--', 'sshd.service')
       provider.mask
     end
+
+    it "masks a service that doesn't exist" do
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'doesnotexist.service'))
+      expect(provider).to receive(:execute).
+                            with(['/bin/systemctl','cat', '--', 'doesnotexist.service'], :failonfail => false).
+                            and_return(Puppet::Util::Execution::ProcessOutput.new("No files found for doesnotexist.service.\n", 1))
+      expect(provider).to receive(:systemctl).with(:mask, '--', 'doesnotexist.service')
+      provider.mask
+    end
   end
 
   # Note: systemd provider does not care about hasstatus or a custom status
   # command. I just assume that it does not make sense for systemd.
   describe "#status" do
-    it "should return running if if the command returns 0" do
+    it "should return running if the command returns 0" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      expect(provider).to receive(:execute).with(['/bin/systemctl','is-active', '--', 'sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("active\n")
-      allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+      expect(provider).to receive(:execute)
+        .with(['/bin/systemctl','is-active', '--', 'sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        .and_return(Puppet::Util::Execution::ProcessOutput.new("active\n", 0))
       expect(provider.status).to eq(:running)
     end
 
     [-10,-1,3,10].each { |ec|
       it "should return stopped if the command returns something non-0" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        expect(provider).to receive(:execute).with(['/bin/systemctl','is-active', '--', 'sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).and_return("inactive\n")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+        expect(provider).to receive(:execute)
+          .with(['/bin/systemctl','is-active', '--', 'sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+          .and_return(Puppet::Util::Execution::ProcessOutput.new("inactive\n", ec))
         expect(provider.status).to eq(:stopped)
       end
     }
 
     it "should use the supplied status command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :status => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :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)
+        .and_return(process_output)
       provider.status
     end
   end
@@ -430,8 +451,7 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     [104, 106].each do |status|
       it "should return true when invoke-rc.d returns #{status}" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        allow(provider).to receive(:system)
-        expect($CHILD_STATUS).to receive(:exitstatus).and_return(status)
+        allow(provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
         expect(provider.debian_enabled?).to eq(:true)
       end
     end
@@ -439,17 +459,15 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     [101, 105].each do |status|
       it "should return true when status is #{status} and there are at least 4 start links" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        allow(provider).to receive(:system)
+        allow(provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
         expect(provider).to receive(:get_start_link_count).and_return(4)
-        expect($CHILD_STATUS).to receive(:exitstatus).twice.and_return(status)
         expect(provider.debian_enabled?).to eq(:true)
       end
 
       it "should return false when status is #{status} and there are less than 4 start links" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-        allow(provider).to receive(:system)
+        allow(provider).to receive(:execute).and_return(Puppet::Util::Execution::ProcessOutput.new('', status))
         expect(provider).to receive(:get_start_link_count).and_return(1)
-        expect($CHILD_STATUS).to receive(:exitstatus).twice.and_return(status)
         expect(provider.debian_enabled?).to eq(:false)
       end
     end
@@ -467,17 +485,39 @@ Jun 14 21:43:23 foo.example.com systemd[1]: sshd.service lacks both ExecStart= a
     context 'when service state is static' do
       let(:service_state) { 'static' }
 
-      it 'is always enabled_insync even if current value is the same as expected' do
-        expect(provider).to be_enabled_insync(:false)
-      end
+      context 'when enable is not mask' do
+        it 'is always enabled_insync even if current value is the same as expected' do
+          expect(provider).to be_enabled_insync(:false)
+        end
 
-      it 'is always enabled_insync even if current value is not the same as expected' do
-        expect(provider).to be_enabled_insync(:true)
+        it 'is always enabled_insync even if current value is not the same as expected' do
+          expect(provider).to be_enabled_insync(:true)
+        end
+
+        it 'logs a debug messsage' do
+          expect(Puppet).to receive(:debug).with("Unable to enable or disable static service sshd.service")
+          provider.enabled_insync?(:true)
+        end
       end
 
-      it 'logs a debug messsage' do
-        expect(Puppet).to receive(:debug).with("Unable to enable or disable static service sshd.service")
-        provider.enabled_insync?(:true)
+      context 'when enable is mask' do
+        let(:provider) do
+          provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service',
+                                                             :enable => 'mask'))
+        end
+
+        it 'is enabled_insync if current value is the same as expected' do
+          expect(provider).to be_enabled_insync(:mask)
+        end
+
+        it 'is not enabled_insync if current value is not the same as expected' do
+          expect(provider).not_to be_enabled_insync(:true)
+        end
+
+        it 'logs no debug messsage' do
+          expect(Puppet).not_to receive(:debug)
+          provider.enabled_insync?(:true)
+        end
       end
     end