puppet 6.0.10-x86-mingw32 → 6.1.0-x86-mingw32

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

@@ -12,44 +12,44 @@ describe 'Puppet::Type::Service::Provider::Debian',
 
   before(:each) do
     # Create a mock resource
-    @resource = double('resource')
+    @resource = stub 'resource'
 
     @provider = provider_class.new
 
     # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
+    @resource.stubs(:[]).returns(nil)
 
     # But set name, source and path
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:enabled)
-    allow(@resource).to receive(:ref).and_return("Service[myservice]")
+    @resource.stubs(:[]).with(:name).returns "myservice"
+    @resource.stubs(:[]).with(:ensure).returns :enabled
+    @resource.stubs(:ref).returns "Service[myservice]"
 
     @provider.resource = @resource
 
-    allow(@provider).to receive(:command).with(:update_rc).and_return("update_rc")
-    allow(@provider).to receive(:command).with(:invoke_rc).and_return("invoke_rc")
-    allow(@provider).to receive(:command).with(:service).and_return("service")
+    @provider.stubs(:command).with(:update_rc).returns "update_rc"
+    @provider.stubs(:command).with(:invoke_rc).returns "invoke_rc"
+    @provider.stubs(:command).with(:service).returns "service"
 
-    allow(@provider).to receive(:update_rc)
-    allow(@provider).to receive(:invoke_rc)
+    @provider.stubs(:update_rc)
+    @provider.stubs(:invoke_rc)
   end
 
   ['1','2'].each do |version|
     it "should be the default provider on CumulusLinux #{version}" do
-      expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return('CumulusLinux')
-      expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return(version)
+      Facter.expects(:value).with(:operatingsystem).at_least_once.returns('CumulusLinux')
+      Facter.expects(:value).with(:operatingsystemmajrelease).returns(version)
       expect(provider_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on Devuan" do
-    expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return('Devuan')
+    Facter.expects(:value).with(:operatingsystem).at_least_once.returns('Devuan')
     expect(provider_class.default?).to be_truthy
   end
 
   it "should be the default provider on Debian" do
-    expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return('Debian')
-    expect(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('7')
+    Facter.expects(:value).with(:operatingsystem).at_least_once.returns('Debian')
+    Facter.expects(:value).with(:operatingsystemmajrelease).returns('7')
     expect(provider_class.default?).to be_truthy
   end
 
@@ -67,25 +67,25 @@ describe 'Puppet::Type::Service::Provider::Debian',
 
   context "when enabling" do
     it "should call update-rc.d twice" do
-      expect(@provider).to receive(:update_rc).twice
+      @provider.expects(:update_rc).twice
       @provider.enable
     end
   end
 
   context "when disabling" do
     it "should be able to disable services with newer sysv-rc versions" do
-      allow(@provider).to receive(:`).with("dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?").and_return("0")
+      @provider.stubs(:`).with("dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?").returns "0"
 
-      expect(@provider).to receive(:update_rc).with(@resource[:name], "disable")
+      @provider.expects(:update_rc).with(@resource[:name], "disable")
 
       @provider.disable
     end
 
     it "should be able to enable services with older sysv-rc versions" do
-      allow(@provider).to receive(:`).with("dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?").and_return("1")
+      @provider.stubs(:`).with("dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?").returns "1"
 
-      expect(@provider).to receive(:update_rc).with("-f", @resource[:name], "remove")
-      expect(@provider).to receive(:update_rc).with(@resource[:name], "stop", "00", "1", "2", "3", "4", "5", "6", ".")
+      @provider.expects(:update_rc).with("-f", @resource[:name], "remove")
+      @provider.expects(:update_rc).with(@resource[:name], "stop", "00", "1", "2", "3", "4", "5", "6", ".")
 
       @provider.disable
     end
@@ -93,34 +93,34 @@ describe 'Puppet::Type::Service::Provider::Debian',
 
   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)
+      @provider.expects(:system).with("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start").once
+      $CHILD_STATUS.stubs(:exitstatus).returns(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)
+      @provider.stubs(:system)
+      $CHILD_STATUS.stubs(:exitstatus).returns(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)
+      @provider.stubs(:system)
+      $CHILD_STATUS.stubs(:exitstatus).returns(106)
       expect(@provider.enabled?).to eq(:true)
     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(:get_start_link_count).and_return(4)
+        @provider.stubs(:system)
+        $CHILD_STATUS.stubs(:exitstatus).returns(status)
+        @provider.stubs(:get_start_link_count).returns(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(:get_start_link_count).and_return(3)
+        @provider.stubs(:system)
+        $CHILD_STATUS.stubs(:exitstatus).returns(status)
+        @provider.stubs(:get_start_link_count).returns(3)
         expect(@provider.enabled?).to eq(:false)
       end
     end
@@ -144,8 +144,8 @@ 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)
+        @provider.stubs(:system)
+        $CHILD_STATUS.stubs(:exitstatus).returns(exitstatus)
         expect(@provider.enabled?).to eq(:false)
       end
     end
@@ -153,9 +153,9 @@ describe 'Puppet::Type::Service::Provider::Debian',
 
   context "when checking service status" do
     it "should use the service command" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return('Debian')
-      allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return('8')
-      allow(@resource).to receive(:[]).with(:hasstatus).and_return(:true)
+      Facter.stubs(:value).with(:operatingsystem).returns('Debian')
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns('8')
+      @resource.stubs(:[]).with(:hasstatus).returns(:true)
       expect(@provider.statuscmd).to eq(["service", @resource[:name], "status"])
     end
   end

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

@@ -6,12 +6,12 @@ describe 'Puppet::Type::Service::Provider::Freebsd',
 
   before :each do
     @provider = provider_class.new
-    allow(@provider).to receive(:initscript)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
+    @provider.stubs(:initscript)
+    Facter.stubs(:value).with(:osfamily).returns 'FreeBSD'
   end
 
   it "should correctly parse rcvar for FreeBSD < 7" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
+    @provider.stubs(:execute).returns <<OUTPUT
 # ntpd
 $ntpd_enable=YES
 OUTPUT
@@ -19,7 +19,7 @@ OUTPUT
   end
 
   it "should correctly parse rcvar for FreeBSD 7 to 8" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
+    @provider.stubs(:execute).returns <<OUTPUT
 # ntpd
 ntpd_enable=YES
 OUTPUT
@@ -27,7 +27,7 @@ OUTPUT
   end
 
   it "should correctly parse rcvar for FreeBSD >= 8.1" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
+    @provider.stubs(:execute).returns <<OUTPUT
 # ntpd
 #
 ntpd_enable="YES"
@@ -37,7 +37,7 @@ OUTPUT
   end
 
   it "should correctly parse rcvar for DragonFly BSD" do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
+    @provider.stubs(:execute).returns <<OUTPUT
 # ntpd
 $ntpd=YES
 OUTPUT
@@ -45,7 +45,7 @@ OUTPUT
   end
 
   it 'should parse service names with a description' do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
+    @provider.stubs(:execute).returns <<OUTPUT
 # local_unbound : local caching forwarding resolver
 local_unbound_enable="YES"
 OUTPUT
@@ -53,7 +53,7 @@ OUTPUT
   end
 
   it 'should parse service names without a description' do
-    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
+    @provider.stubs(:execute).returns <<OUTPUT
 # local_unbound
 local_unbound="YES"
 OUTPUT
@@ -61,31 +61,31 @@ OUTPUT
   end
 
   it "should find the right rcvar_value for FreeBSD < 7" do
-    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable=YES'])
+    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable=YES'])
 
     expect(@provider.rcvar_value).to eq("YES")
   end
 
   it "should find the right rcvar_value for FreeBSD >= 7" do
-    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
+    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
 
     expect(@provider.rcvar_value).to eq("YES")
   end
 
   it "should find the right rcvar_name" do
-    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable="YES"'])
+    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable="YES"'])
 
     expect(@provider.rcvar_name).to eq("ntpd")
   end
 
   it "should enable only the selected service" do
-    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)
-    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)
+    Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf').returns(true)
+    File.stubs(:read).with('/etc/rc.conf').returns("openntpd_enable=\"NO\"\nntpd_enable=\"NO\"\n")
+    fh = stub 'fh'
+    File.stubs(:open).with('/etc/rc.conf', File::WRONLY).yields(fh)
+    fh.expects(:<<).with("openntpd_enable=\"NO\"\nntpd_enable=\"YES\"\n")
+    Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.local').returns(false)
+    Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/ntpd').returns(false)
 
     @provider.rc_replace('ntpd', 'ntpd', 'YES')
   end

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

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Gentoo', unless: Puppet::Util::Platform.jruby? do
@@ -10,17 +12,18 @@ describe 'Puppet::Type::Service::Provider::Gentoo', unless: Puppet::Util::Platfo
   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)
-    allow(FileTest).to receive(:executable?).with('/sbin/rc-update').and_return(true)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('Gentoo')
-    allow(Facter).to receive(:value).with(:osfamily).and_return('Gentoo')
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
+    FileTest.stubs(:file?).with('/sbin/rc-update').returns true
+    FileTest.stubs(:executable?).with('/sbin/rc-update').returns true
+    Facter.stubs(:value).with(:operatingsystem).returns 'Gentoo'
+    Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
 
     # The initprovider (parent of the gentoo provider) does a stat call
     # before it even tries to execute an initscript. We use sshd in all the
     # tests so make sure it is considered present.
     sshd_path = '/etc/init.d/sshd'
-    allow(Puppet::FileSystem).to receive(:stat).with(sshd_path).and_return(double('stat'))
+#    stub_file = stub(sshd_path, :stat => stub('stat'))
+    Puppet::FileSystem.stubs(:stat).with(sshd_path).returns stub('stat')
   end
 
   let :initscripts do
@@ -48,21 +51,22 @@ describe 'Puppet::Type::Service::Provider::Gentoo', unless: Puppet::Util::Platfo
   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 /etc/init.d but exclude helper scripts" do
-      expect(FileTest).to receive(:directory?).with('/etc/init.d').and_return(true)
-      expect(Dir).to receive(:entries).with('/etc/init.d').and_return(initscripts)
+      FileTest.expects(:directory?).with('/etc/init.d').returns true
+      Dir.expects(:entries).with('/etc/init.d').returns initscripts
       (initscripts - helperscripts).each do |script|
-        expect(FileTest).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
+        FileTest.expects(:executable?).with("/etc/init.d/#{script}").returns true
       end
       helperscripts.each do |script|
-        expect(FileTest).not_to receive(:executable?).with("/etc/init.d/#{script}")
+        FileTest.expects(:executable?).with("/etc/init.d/#{script}").never
       end
 
-      allow(Puppet::FileSystem).to receive(:symlink?).and_return(false)
+      Puppet::FileSystem.stubs(:symlink?).returns false # stub('file', :symlink? => false)
       expect(provider_class.instances.map(&:name)).to eq([
         'alsasound',
         'bootmisc',
@@ -79,14 +83,13 @@ describe 'Puppet::Type::Service::Provider::Gentoo', 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 <initscript> start otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
+      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
       provider.start
     end
   end
@@ -94,26 +97,26 @@ describe 'Puppet::Type::Service::Provider::Gentoo', 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 <initscript> stop otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
+      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
       provider.stop
     end
   end
 
   describe "#enabled?" do
+
     before :each do
-      allow_any_instance_of(provider_class).to receive(:update).with(:show).and_return(File.read(my_fixture('rc_update_show')))
+      provider_class.any_instance.stubs(:update).with(:show).returns File.read(my_fixture('rc_update_show'))
     end
 
     it "should run rc-update show to get a list of enabled services" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:update).with(:show).and_return("\n")
+      provider.expects(:update).with(:show).returns "\n"
       provider.enabled?
     end
 
@@ -143,7 +146,7 @@ describe 'Puppet::Type::Service::Provider::Gentoo', 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(:update).with(:add, 'sshd', :default)
+      provider.expects(:update).with(:add, 'sshd', :default)
       provider.enable
     end
   end
@@ -151,34 +154,35 @@ describe 'Puppet::Type::Service::Provider::Gentoo', 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(:update).with(:del, 'sshd', :default)
+      provider.expects(:update).with(:del, 'sshd', :default)
       provider.disable
     end
   end
 
   describe "#status" do
+
     describe "when a special status command is 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(['/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)
+        provider.expects(:execute).with(['/etc/init.d/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 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)
+        provider.expects(:execute).with(['/etc/init.d/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 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)
+        provider.expects(:execute).with(['/etc/init.d/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
@@ -186,15 +190,15 @@ describe 'Puppet::Type::Service::Provider::Gentoo', 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(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        expect(provider).to receive(:getpid).and_return(1000)
+        provider.expects(:execute).with(['/etc/init.d/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(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
-        expect(provider).to receive(:getpid).and_return(nil)
+        provider.expects(:execute).with(['/etc/init.d/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
@@ -202,17 +206,17 @@ describe 'Puppet::Type::Service::Provider::Gentoo', unless: Puppet::Util::Platfo
     describe "when hasstatus is true" do
       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)
+        provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+        provider.expects(:execute).with(['/etc/init.d/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 <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)
+        provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+        provider.expects(:execute).with(['/etc/init.d/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
@@ -221,25 +225,26 @@ describe 'Puppet::Type::Service::Provider::Gentoo', 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(['/etc/init.d/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(['/etc/init.d/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 <initscript> restart if hasrestart is true" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with <initscript> stop/start if hasrestart is false" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
-      expect(provider).not_to receive(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
   end
+
 end