puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

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

@@ -5,11 +5,11 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   let(:provider_class) { Puppet::Type.type(:service).provider(:openbsd) }
 
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:openbsd)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('OpenBSD')
-    allow(FileTest).to receive(:file?).with('/usr/sbin/rcctl').and_return(true)
-    allow(FileTest).to receive(:executable?).with('/usr/sbin/rcctl').and_return(true)
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
+    Facter.stubs(:value).with(:operatingsystem).returns :openbsd
+    Facter.stubs(:value).with(:osfamily).returns 'OpenBSD'
+    FileTest.stubs(:file?).with('/usr/sbin/rcctl').returns true
+    FileTest.stubs(:executable?).with('/usr/sbin/rcctl').returns true
   end
 
   context "#instances" do
@@ -18,7 +18,7 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
     end
 
     it "should list all available services" do
-      allow(provider_class).to receive(:execpipe).with(['/usr/sbin/rcctl', :getall]).and_yield(File.read(my_fixture('rcctl_getall')))
+      provider_class.stubs(:execpipe).with(['/usr/sbin/rcctl', :getall]).yields File.read(my_fixture('rcctl_getall'))
       expect(provider_class.instances.map(&:name)).to eq([
         'accounting', 'pf', 'postgresql', 'tftpd', 'wsmoused', 'xdm',
       ])
@@ -28,13 +28,13 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#start" do
     it "should use the supplied start command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
 
     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)
+      provider.expects(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
       provider.start
     end
   end
@@ -42,13 +42,13 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#stop" do
     it "should use the supplied stop command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     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)
+      provider.expects(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
       provider.stop
     end
   end
@@ -56,24 +56,24 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#status" do
     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)
+      provider.expects(:execute).with(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       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)
+      provider.expects(:execute).with(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+      $CHILD_STATUS.stubs(:exitstatus).returns 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)
+      provider.expects(:execute).with(['/usr/sbin/rcctl', :get, 'sshd', :status], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+      $CHILD_STATUS.stubs(:exitstatus).returns 0
       expect(provider.status).to eq(:running)
     end
   end
@@ -81,22 +81,22 @@ describe 'Puppet::Type::Service::Provider::Openbsd',
   context "#restart" do
     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)
+      provider.expects(:execute).with(['/usr/sbin/rcctl', '-f', :restart, 'sshd'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       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)
+      provider.expects(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], 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)
+      provider.expects(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], true).never
+      provider.expects(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
+      provider.expects(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
       provider.restart
     end
   end
@@ -104,15 +104,15 @@ 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))
+      provider_class.stubs(:rcctl).with(:get, 'sshd', :status)
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).returns(stub(: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))
+      provider_class.stubs(:rcctl).with(:get, 'sshd', :status).returns('NO')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'status'], :failonfail => false, :combine => false, :squelch => false).returns(stub(:exitstatus => 1))
       expect(provider.enabled?).to eq(:false)
     end
   end
@@ -120,17 +120,17 @@ 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_class.stubs(:rcctl).with(:enable, 'sshd').returns('')
+      provider.expects(: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_class.stubs(:rcctl).with(:enable, 'sshd').returns('')
+      provider_class.stubs(:rcctl).with(:set, 'sshd', :flags, '-6').returns('')
+      provider.expects(:rcctl).with(:enable, 'sshd')
+      provider.expects(:rcctl).with(:set, 'sshd', :flags, '-6')
       provider.enable
     end
   end
@@ -138,8 +138,8 @@ 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_class.stubs(:rcctl).with(:disable, 'sshd').returns('')
+      provider.expects(:rcctl).with(:disable, 'sshd')
       provider.disable
     end
   end
@@ -147,22 +147,22 @@ 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)')
+      provider_class.stubs(:rcctl).with(:check, 'sshd').returns('sshd(ok)')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).returns('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)')
+      provider_class.stubs(:rcctl).with(:check, 'sshd').returns('sshd(ok)')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).returns('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)')
+      provider_class.stubs(:rcctl).with(:check, 'sshd').returns('sshd(failed)')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'check', 'sshd'], :failonfail => false, :combine => false, :squelch => false).returns('sshd(failed)')
       expect(provider.running?).to be_nil
     end
   end
@@ -170,22 +170,22 @@ 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_class.stubs(:rcctl).with('get', 'sshd', 'flags').returns('-6')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], :failonfail => false, :combine => false, :squelch => false).returns('-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_class.stubs(:rcctl).with('get', 'sshd', 'flags').returns('')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'sshd', 'flags'], :failonfail => false, :combine => false, :squelch => false).returns('')
       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_class.stubs(:rcctl).with('get', 'pf', 'flags').returns('YES')
+      provider.expects(:execute).with(['/usr/sbin/rcctl', 'get', 'pf', 'flags'], :failonfail => false, :combine => false, :squelch => false).returns('YES')
       provider.flags
     end
   end
@@ -193,8 +193,8 @@ 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(:rcctl).with(:set, 'sshd', :flags, '-4')
+      provider_class.stubs(:rcctl).with(:set, 'sshd', :flags, '-4').returns('')
+      provider.expects(:rcctl).with(:set, 'sshd', :flags, '-4')
       provider.flags = '-4'
     end
   end

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

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platform.jruby? do
@@ -10,22 +12,23 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
   end
 
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
     ['/sbin/rc-service', '/bin/rc-status', '/sbin/rc-update'].each do |command|
       # Puppet::Util is both mixed in to providers and is also invoked directly
       # by Puppet::Provider::CommandDefiner, so we have to stub both out.
-      allow(provider_class).to receive(:which).with(command).and_return(command)
-      allow(Puppet::Util).to receive(:which).with(command).and_return(command)
+      provider_class.stubs(:which).with(command).returns(command)
+      Puppet::Util.stubs(:which).with(command).returns(command)
     end
   end
 
   describe ".instances" do
+
     it "should have an instances method" do
       expect(provider_class).to respond_to :instances
     end
 
     it "should get a list of services from rc-service --list" do
-      expect(provider_class).to receive(:rcservice).with('-C','--list').and_return(File.read(my_fixture('rcservice_list')))
+      provider_class.expects(:rcservice).with('-C','--list').returns File.read(my_fixture('rcservice_list'))
       expect(provider_class.instances.map(&:name)).to eq([
         'alsasound',
         'consolefont',
@@ -42,13 +45,12 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
-
     it "should start the service with rc-service start otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
   end
@@ -56,40 +58,38 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
   describe "#stop" do
     it "should use the supplied stop command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
-
     it "should stop the service with rc-service stop otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
   end
 
   describe 'when invoking `rc-status`' do
     subject { provider_class.new(Puppet::Type.type(:service).new(:name => 'urandom')) }
-
     it "clears the RC_SVCNAME environment variable" do
       Puppet::Util.withenv(:RC_SVCNAME => 'puppet') do
-        expect(Puppet::Util::Execution).to receive(:execute).with(
-          include('/bin/rc-status'),
-          hash_including(custom_environment:  hash_including(RC_SVCNAME: nil))
-        ).and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-
+        Puppet::Util::Execution.expects(:execute).with(
+          includes('/bin/rc-status'),
+          has_entry(:custom_environment, {:RC_SVCNAME => nil})
+        ).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
         subject.enabled?
       end
     end
   end
 
   describe "#enabled?" do
+
     before :each do
-      allow_any_instance_of(provider_class).to receive(:rcstatus).with('-C','-a').and_return(File.read(my_fixture('rcstatus')))
+      provider_class.any_instance.stubs(:rcstatus).with('-C','-a').returns File.read(my_fixture('rcstatus'))
     end
 
     it "should run rc-status to get a list of enabled services" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:rcstatus).with('-C','-a').and_return("\n")
+      provider.expects(:rcstatus).with('-C','-a').returns "\n"
       provider.enabled?
     end
 
@@ -133,7 +133,7 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
   describe "#enable" do
     it "should run rc-update add to enable a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:rcupdate).with('-C', :add, 'sshd')
+      provider.expects(:rcupdate).with('-C', :add, 'sshd')
       provider.enable
     end
   end
@@ -141,34 +141,35 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
   describe "#disable" do
     it "should run rc-update del to disable a service" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:rcupdate).with('-C', :del, 'sshd')
+      provider.expects(:rcupdate).with('-C', :del, 'sshd')
       provider.disable
     end
   end
 
   describe "#status" do
+
     describe "when a special status command if specified" do
       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)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 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)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 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)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 0
         expect(provider.status).to eq(:running)
       end
     end
@@ -176,15 +177,15 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
     describe "when hasstatus is false" do
       it "should return running if a pid can be found" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        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(:getpid).and_return(1000)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:getpid).returns 1000
         expect(provider.status).to eq(:running)
       end
 
       it "should return stopped if no pid can be found" do
         provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        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(:getpid).and_return(nil)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:getpid).returns nil
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -192,15 +193,15 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
     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)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 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)
+        provider.expects(:execute).with(['/sbin/rc-service','sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        $CHILD_STATUS.stubs(:exitstatus).returns 3
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -209,23 +210,24 @@ describe 'Puppet::Type::Service::Provider::Openrc', unless: Puppet::Util::Platfo
   describe "#restart" do
     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(['/sbin/rc-service','sshd',:restart], :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)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with rc-service restart if hasrestart is true" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with rc-service 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(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/sbin/rc-service','sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/sbin/rc-service','sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
   end
+
 end