puppet 7.4.0-x64-mingw32 → 7.8.0-x64-mingw32

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
 

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