puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

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

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.features.microsoft_windows? do
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_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
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_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)
   end
 
   context "#instances" do
@@ -15,7 +15,7 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
     end
 
     it "should list all available services" do
-      described_class.stubs(:execpipe).with(['/usr/sbin/rcctl', :getall]).yields File.read(my_fixture('rcctl_getall'))
+      allow(described_class).to receive(:execpipe).with(['/usr/sbin/rcctl', :getall]).and_yield(File.read(my_fixture('rcctl_getall')))
       expect(described_class.instances.map(&:name)).to eq([
         'accounting', 'pf', 'postgresql', 'tftpd', 'wsmoused', 'xdm',
       ])
@@ -25,13 +25,13 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#start" do
     it "should use the supplied start command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      provider.expects(: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)
       provider.start
     end
 
     it "should start the service otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
+      expect(provider).to receive(:texecute).with(:start, ['/usr/sbin/rcctl', '-f', :start, 'sshd'], true)
       provider.start
     end
   end
@@ -39,13 +39,13 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#stop" do
     it "should use the supplied stop command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      provider.expects(: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)
       provider.stop
     end
 
     it "should stop the service otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
+      expect(provider).to receive(:texecute).with(:stop, ['/usr/sbin/rcctl', :stop, 'sshd'], true)
       provider.stop
     end
   end
@@ -53,24 +53,24 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#status" do
     it "should use the status command from the resource" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      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)
+      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.status
     end
 
     it "should return :stopped when status command returns with a non-zero exitcode" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      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).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.status).to eq(:stopped)
     end
 
     it "should return :running when status command returns with a zero exitcode" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      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).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.status).to eq(:running)
     end
   end
@@ -78,22 +78,22 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#restart" do
     it "should use the supplied restart command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      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)
+      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.restart
     end
 
     it "should restart the service with rcctl restart if hasrestart is true" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      provider.expects(:texecute).with(:restart, ['/usr/sbin/rcctl', '-f', :restart, 'sshd'], true)
+      expect(provider).to receive(: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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      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)
+      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.restart
     end
   end
@@ -101,15 +101,15 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_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))
+      allow(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_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))
+      allow(described_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.enabled?).to eq(:false)
     end
   end
@@ -117,17 +117,17 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#enable" do
     it "should run rcctl enable to enable the service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_class.stubs(:rcctl).with(:enable, 'sshd').returns('')
-      provider.expects(:rcctl).with(:enable, 'sshd')
+      allow(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :flags => '-6'))
-      described_class.stubs(:rcctl).with(:enable, 'sshd').returns('')
-      described_class.stubs(:rcctl).with(:set, 'sshd', :flags, '-6').returns('')
-      provider.expects(:rcctl).with(:enable, 'sshd')
-      provider.expects(:rcctl).with(:set, 'sshd', :flags, '-6')
+      allow(described_class).to receive(:rcctl).with(:enable, 'sshd').and_return('')
+      allow(described_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
     end
   end
@@ -135,8 +135,8 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#disable" do
     it "should run rcctl disable to disable the service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_class.stubs(:rcctl).with(:disable, 'sshd').returns('')
-      provider.expects(:rcctl).with(:disable, 'sshd')
+      allow(described_class).to receive(:rcctl).with(:disable, 'sshd').and_return('')
+      expect(provider).to receive(:rcctl).with(:disable, 'sshd')
       provider.disable
     end
   end
@@ -144,22 +144,22 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#running?" do
     it "should run rcctl check to check the service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_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)')
+      allow(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_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)')
+      allow(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_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)')
+      allow(described_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
   end
@@ -167,22 +167,22 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#flags" do
     it "should return flags when set" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :flags => '-6'))
-      described_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')
+      allow(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_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('')
+      allow(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'pf'))
-      described_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')
+      allow(described_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
   end
@@ -190,8 +190,8 @@ describe Puppet::Type.type(:service).provider(:openbsd), :unless => Puppet.featu
   context "#flags=" do
     it "should run rcctl to set flags" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      described_class.stubs(:rcctl).with(:set, 'sshd', :flags, '-4').returns('')
-      provider.expects(:rcctl).with(:set, 'sshd', :flags, '-4')
+      allow(described_class).to receive(:rcctl).with(:set, 'sshd', :flags, '-4').and_return('')
+      expect(provider).to receive(:rcctl).with(:set, 'sshd', :flags, '-4')
       provider.flags = '-4'
     end
   end

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

@@ -1,9 +1,6 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:openrc) do
-
   if Puppet.features.microsoft_windows?
     # Get a pid for $CHILD_STATUS to latch on to
     cmd = "cmd.exe /c \"exit 0\""
@@ -11,23 +8,22 @@ describe Puppet::Type.type(:service).provider(:openrc) do
   end
 
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_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.
-      described_class.stubs(:which).with(command).returns(command)
-      Puppet::Util.stubs(:which).with(command).returns(command)
+      allow(described_class).to receive(:which).with(command).and_return(command)
+      allow(Puppet::Util).to receive(:which).with(command).and_return(command)
     end
   end
 
   describe ".instances" do
-
     it "should have an instances method" do
       expect(described_class).to respond_to :instances
     end
 
     it "should get a list of services from rc-service --list" do
-      described_class.expects(:rcservice).with('-C','--list').returns File.read(my_fixture('rcservice_list'))
+      expect(described_class).to receive(:rcservice).with('-C','--list').and_return(File.read(my_fixture('rcservice_list')))
       expect(described_class.instances.map(&:name)).to eq([
         'alsasound',
         'consolefont',
@@ -44,12 +40,13 @@ describe Puppet::Type.type(:service).provider(:openrc) do
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      provider.expects(: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)
       provider.start
     end
+
     it "should start the service with rc-service start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/sbin/rc-service','sshd',:start], :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.start
     end
   end
@@ -57,38 +54,40 @@ describe Puppet::Type.type(:service).provider(:openrc) do
   describe "#stop" do
     it "should use the supplied stop command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      provider.expects(: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)
       provider.stop
     end
+
     it "should stop the service with rc-service stop otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(: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',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
   end
 
   describe 'when invoking `rc-status`' do
     subject { described_class.new(Puppet::Type.type(:service).new(:name => 'urandom')) }
+
     it "clears the RC_SVCNAME environment variable" do
       Puppet::Util.withenv(:RC_SVCNAME => 'puppet') do
-        Puppet::Util::Execution.expects(:execute).with(
-          includes('/bin/rc-status'),
-          has_entry(:custom_environment, {:RC_SVCNAME => nil})
-        ).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        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))
+
         subject.enabled?
       end
     end
   end
 
   describe "#enabled?" do
-
     before :each do
-      described_class.any_instance.stubs(:rcstatus).with('-C','-a').returns File.read(my_fixture('rcstatus'))
+      allow_any_instance_of(described_class).to receive(:rcstatus).with('-C','-a').and_return(File.read(my_fixture('rcstatus')))
     end
 
     it "should run rc-status to get a list of enabled services" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:rcstatus).with('-C','-a').returns "\n"
+      expect(provider).to receive(:rcstatus).with('-C','-a').and_return("\n")
       provider.enabled?
     end
 
@@ -132,7 +131,7 @@ describe Puppet::Type.type(:service).provider(:openrc) do
   describe "#enable" do
     it "should run rc-update add to enable a service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:rcupdate).with('-C', :add, 'sshd')
+      expect(provider).to receive(:rcupdate).with('-C', :add, 'sshd')
       provider.enable
     end
   end
@@ -140,35 +139,34 @@ describe Puppet::Type.type(:service).provider(:openrc) do
   describe "#disable" do
     it "should run rc-update del to disable a service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:rcupdate).with('-C', :del, 'sshd')
+      expect(provider).to receive(: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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        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).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.status
       end
 
       it "should return :stopped when status command returns with a non-zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        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).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.status).to eq(:stopped)
       end
 
       it "should return :running when status command returns with a zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        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).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.status).to eq(:running)
       end
     end
@@ -176,15 +174,15 @@ describe Puppet::Type.type(:service).provider(:openrc) do
     describe "when hasstatus is false" do
       it "should return running if a pid can be found" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        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).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)
         expect(provider.status).to eq(:running)
       end
 
       it "should return stopped if no pid can be found" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        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).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)
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -192,15 +190,15 @@ describe Puppet::Type.type(:service).provider(:openrc) do
     describe "when hasstatus is true" do
       it "should return running if rc-service status exits with a zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        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).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.status).to eq(:running)
       end
 
       it "should return stopped if rc-service status exits with a non-zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        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).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.status).to eq(:stopped)
       end
     end
@@ -209,24 +207,23 @@ describe Puppet::Type.type(:service).provider(:openrc) do
   describe "#restart" do
     it "should use the supplied restart command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      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)
+      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.restart
     end
 
     it "should restart the service with rc-service restart if hasrestart is true" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      provider.expects(: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',: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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      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)
+      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.restart
     end
   end
-
 end