puppet 5.5.12-x86-mingw32 → 5.5.13-x86-mingw32

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

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

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

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Puppet::Type.type(:service).provider(:freebsd) do
   before :each do
     @provider = subject()
-    @provider.stubs(:initscript)
-    Facter.stubs(:value).with(:osfamily).returns 'FreeBSD'
+    allow(@provider).to receive(:initscript)
+    allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
   end
 
   it "should correctly parse rcvar for FreeBSD < 7" do
-    @provider.stubs(:execute).returns <<OUTPUT
+    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
 # ntpd
 $ntpd_enable=YES
 OUTPUT
@@ -16,7 +16,7 @@ OUTPUT
   end
 
   it "should correctly parse rcvar for FreeBSD 7 to 8" do
-    @provider.stubs(:execute).returns <<OUTPUT
+    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
 # ntpd
 ntpd_enable=YES
 OUTPUT
@@ -24,7 +24,7 @@ OUTPUT
   end
 
   it "should correctly parse rcvar for FreeBSD >= 8.1" do
-    @provider.stubs(:execute).returns <<OUTPUT
+    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
 # ntpd
 #
 ntpd_enable="YES"
@@ -34,7 +34,7 @@ OUTPUT
   end
 
   it "should correctly parse rcvar for DragonFly BSD" do
-    @provider.stubs(:execute).returns <<OUTPUT
+    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
 # ntpd
 $ntpd=YES
 OUTPUT
@@ -42,7 +42,7 @@ OUTPUT
   end
 
   it 'should parse service names with a description' do
-    @provider.stubs(:execute).returns <<OUTPUT
+    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
 # local_unbound : local caching forwarding resolver
 local_unbound_enable="YES"
 OUTPUT
@@ -50,7 +50,7 @@ OUTPUT
   end
 
   it 'should parse service names without a description' do
-    @provider.stubs(:execute).returns <<OUTPUT
+    allow(@provider).to receive(:execute).and_return(<<OUTPUT)
 # local_unbound
 local_unbound="YES"
 OUTPUT
@@ -58,31 +58,31 @@ OUTPUT
   end
 
   it "should find the right rcvar_value for FreeBSD < 7" do
-    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable=YES'])
+    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable=YES'])
 
     expect(@provider.rcvar_value).to eq("YES")
   end
 
   it "should find the right rcvar_value for FreeBSD >= 7" do
-    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
+    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable="YES"', '#   (default: "")'])
 
     expect(@provider.rcvar_value).to eq("YES")
   end
 
   it "should find the right rcvar_name" do
-    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable="YES"'])
+    allow(@provider).to receive(:rcvar).and_return(['# ntpd', 'ntpd_enable="YES"'])
 
     expect(@provider.rcvar_name).to eq("ntpd")
   end
 
   it "should enable only the selected service" do
-    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)
+    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)
 
     @provider.rc_replace('ntpd', 'ntpd', 'YES')
   end

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

@@ -1,9 +1,6 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 
 describe Puppet::Type.type(:service).provider(:gentoo) do
-
   if Puppet.features.microsoft_windows?
     # Get a pid for $CHILD_STATUS to latch on to
     command = "cmd.exe /c \"exit 0\""
@@ -11,18 +8,17 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
   end
 
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_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'
+    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_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')
 
     # 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'
-#    stub_file = stub(sshd_path, :stat => stub('stat'))
-    Puppet::FileSystem.stubs(:stat).with(sshd_path).returns stub('stat')
+    allow(Puppet::FileSystem).to receive(:stat).with(sshd_path).and_return(double('stat'))
   end
 
   let :initscripts do
@@ -50,22 +46,21 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
   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 /etc/init.d but exclude helper scripts" do
-      FileTest.expects(:directory?).with('/etc/init.d').returns true
-      Dir.expects(:entries).with('/etc/init.d').returns initscripts
+      expect(FileTest).to receive(:directory?).with('/etc/init.d').and_return(true)
+      expect(Dir).to receive(:entries).with('/etc/init.d').and_return(initscripts)
       (initscripts - helperscripts).each do |script|
-        FileTest.expects(:executable?).with("/etc/init.d/#{script}").returns true
+        expect(FileTest).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
       end
       helperscripts.each do |script|
-        FileTest.expects(:executable?).with("/etc/init.d/#{script}").never
+        expect(FileTest).not_to receive(:executable?).with("/etc/init.d/#{script}")
       end
 
-      Puppet::FileSystem.stubs(:symlink?).returns false # stub('file', :symlink? => false)
+      allow(Puppet::FileSystem).to receive(:symlink?).and_return(false)
       expect(described_class.instances.map(&:name)).to eq([
         'alsasound',
         'bootmisc',
@@ -82,13 +77,14 @@ describe Puppet::Type.type(:service).provider(:gentoo) 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 <initscript> start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => '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')
+      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.start
     end
   end
@@ -96,26 +92,26 @@ describe Puppet::Type.type(:service).provider(:gentoo) 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 <initscript> stop otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => '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')
+      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.stop
     end
   end
 
   describe "#enabled?" do
-
     before :each do
-      described_class.any_instance.stubs(:update).with(:show).returns File.read(my_fixture('rc_update_show'))
+      allow_any_instance_of(described_class).to receive(:update).with(:show).and_return(File.read(my_fixture('rc_update_show')))
     end
 
     it "should run rc-update show to get a list of enabled services" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:update).with(:show).returns "\n"
+      expect(provider).to receive(:update).with(:show).and_return("\n")
       provider.enabled?
     end
 
@@ -145,7 +141,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) 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(:update).with(:add, 'sshd', :default)
+      expect(provider).to receive(:update).with(:add, 'sshd', :default)
       provider.enable
     end
   end
@@ -153,35 +149,34 @@ describe Puppet::Type.type(:service).provider(:gentoo) 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(:update).with(:del, 'sshd', :default)
+      expect(provider).to receive(: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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        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).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.status
       end
 
       it "should return :stopped when the 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(['/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).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(3)
         expect(provider.status).to eq(:stopped)
       end
 
       it "should return :running when the 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(['/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).not_to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
         expect(provider.status).to eq(:running)
       end
     end
@@ -189,15 +184,15 @@ describe Puppet::Type.type(:service).provider(:gentoo) 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(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
-        provider.expects(:getpid).returns 1000
+        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)
         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(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
-        provider.expects(:getpid).returns nil
+        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)
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -205,17 +200,17 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     describe "when hasstatus is true" do
       it "should return running if <initscript> status exits with a zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        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).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
+        expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
         expect(provider.status).to eq(:running)
       end
 
       it "should return stopped if <initscript> status exits with a non-zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
-        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).to receive(:search).with('sshd').and_return('/etc/init.d/sshd')
+        expect(provider).to receive(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+        allow($CHILD_STATUS).to receive(:exitstatus).and_return(3)
         expect(provider.status).to eq(:stopped)
       end
     end
@@ -224,26 +219,25 @@ describe Puppet::Type.type(:service).provider(:gentoo) 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(['/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)
+      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.restart
     end
 
     it "should restart the service with <initscript> restart if hasrestart is true" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => 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)
+      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.restart
     end
 
     it "should restart the service with <initscript> stop/start if hasrestart is false" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      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)
+      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.restart
     end
   end
-
 end