puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,14 +1,17 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:freebsd) do
+describe 'Puppet::Type::Service::Provider::Freebsd', unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:freebsd) }
+
   before :each do
-    @provider = subject()
-    allow(@provider).to receive(:initscript)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('FreeBSD')
+    @provider = provider_class.new
+    @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
@@ -16,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
@@ -24,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"
@@ -34,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
@@ -42,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
@@ -50,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
@@ -58,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,24 +1,29 @@
+#! /usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:gentoo) do
-  if Puppet.features.microsoft_windows?
+describe 'Puppet::Type::Service::Provider::Gentoo', unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:gentoo) }
+
+  if Puppet::Util::Platform.windows?
     # Get a pid for $CHILD_STATUS to latch on to
     command = "cmd.exe /c \"exit 0\""
     Puppet::Util::Execution.execute(command, {:failonfail => false})
   end
 
   before :each do
-    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')
+    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
@@ -46,22 +51,23 @@ 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)
+      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)
-      expect(described_class.instances.map(&:name)).to eq([
+      Puppet::FileSystem.stubs(:symlink?).returns false # stub('file', :symlink? => false)
+      expect(provider_class.instances.map(&:name)).to eq([
         'alsasound',
         'bootmisc',
         'hwclock',
@@ -76,62 +82,61 @@ 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'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider = provider_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)
       provider.start
     end
-
     it "should start the service with <initscript> start otherwise" do
-      provider = described_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 = provider_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')
       provider.start
     end
   end
 
   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'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider = provider_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)
       provider.stop
     end
-
     it "should stop the service with <initscript> stop otherwise" do
-      provider = described_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 = provider_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')
       provider.stop
     end
   end
 
   describe "#enabled?" do
+
     before :each do
-      allow_any_instance_of(described_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 = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:update).with(:show).and_return("\n")
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:update).with(:show).returns "\n"
       provider.enabled?
     end
 
     ['hostname', 'net.lo', 'procfs'].each do |service|
       it "should consider service #{service} in runlevel boot as enabled" do
-        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
         expect(provider.enabled?).to eq(:true)
       end
     end
 
     ['alsasound', 'xdm', 'netmount'].each do |service|
       it "should consider service #{service} in runlevel default as enabled" do
-        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
         expect(provider.enabled?).to eq(:true)
       end
     end
 
     ['rsyncd', 'lighttpd', 'mysql'].each do |service|
       it "should consider unused service #{service} as disabled" do
-        provider = described_class.new(Puppet::Type.type(:service).new(:name => service))
+        provider = provider_class.new(Puppet::Type.type(:service).new(:name => service))
         expect(provider.enabled?).to eq(:false)
       end
     end
@@ -140,77 +145,78 @@ 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'))
-      expect(provider).to receive(:update).with(:add, 'sshd', :default)
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      provider.expects(:update).with(:add, 'sshd', :default)
       provider.enable
     end
   end
 
   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'))
-      expect(provider).to receive(:update).with(:del, 'sshd', :default)
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      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 = described_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 = provider_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
         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'))
-        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 = provider_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.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'))
-        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 = provider_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.status).to eq(:running)
       end
     end
 
     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))
-        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 = provider_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.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))
-        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 = provider_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.status).to eq(:stopped)
       end
     end
 
     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))
-        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 = provider_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.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))
-        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 = provider_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.status).to eq(:stopped)
       end
     end
@@ -218,26 +224,27 @@ 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'))
-      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 = provider_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)
       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))
-      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 = provider_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)
       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))
-      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 = provider_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)
       provider.restart
     end
   end
+
 end

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

@@ -1,14 +1,21 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the Init service Provider
+#
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:init) do
-  if Puppet.features.microsoft_windows?
+describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:init) }
+
+  if Puppet::Util::Platform.windows?
     # Get a pid for $CHILD_STATUS to latch on to
     cmd = "cmd.exe /c \"exit 0\""
     Puppet::Util::Execution.execute(cmd, {:failonfail => false})
   end
 
   before do
-    Puppet::Type.type(:service).defaultprovider = described_class
+    Puppet::Type.type(:service).defaultprovider = provider_class
   end
 
   after do
@@ -38,76 +45,76 @@ describe Puppet::Type.type(:service).provider(:init) do
 
   describe "when getting all service instances" do
     before :each do
-      allow(described_class).to receive(:defpath).and_return('tmp')
+      provider_class.stubs(:defpath).returns('tmp')
 
       @services = ['one', 'two', 'three', 'four', 'umountfs']
-      allow(Dir).to receive(:entries).with('tmp').and_return(@services)
-      expect(FileTest).to receive(:directory?).with('tmp').and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      Dir.stubs(:entries).with('tmp').returns @services
+      FileTest.expects(:directory?).with('tmp').returns(true)
+      FileTest.stubs(:executable?).returns(true)
     end
 
     it "should return instances for all services" do
-      expect(described_class.instances.map(&:name)).to eq(@services)
+      expect(provider_class.instances.map(&:name)).to eq(@services)
     end
 
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
-      expect(described_class.get_services(described_class.defpath, exclude).map(&:name)).to eq(@services - exclude)
+      expect(provider_class.get_services(provider_class.defpath, exclude).map(&:name)).to eq(@services - exclude)
     end
 
     it "should omit a single service from the exclude list" do
       exclude = 'two'
-      expect(described_class.get_services(described_class.defpath, exclude).map(&:name)).to eq(@services - [exclude])
+      expect(provider_class.get_services(provider_class.defpath, exclude).map(&:name)).to eq(@services - [exclude])
     end
 
     it "should omit Yocto services on cisco-wrlinux" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('cisco-wrlinux')
+      Facter.stubs(:value).with(:osfamily).returns 'cisco-wrlinux'
       exclude = 'umountfs'
-      expect(described_class.get_services(described_class.defpath).map(&:name)).to eq(@services - [exclude])
+      expect(provider_class.get_services(provider_class.defpath).map(&:name)).to eq(@services - [exclude])
     end
 
     it "should not omit Yocto services on non cisco-wrlinux platforms" do
-      expect(described_class.get_services(described_class.defpath).map(&:name)).to eq(@services)
+      expect(provider_class.get_services(provider_class.defpath).map(&:name)).to eq(@services)
     end
 
     it "should use defpath" do
-      expect(described_class.instances).to(be_all { |provider| provider.get(:path) == described_class.defpath })
+      expect(provider_class.instances).to be_all { |provider| provider.get(:path) == provider_class.defpath }
     end
 
     it "should set hasstatus to true for providers" do
-      expect(described_class.instances).to(be_all { |provider| provider.get(:hasstatus) == true })
+      expect(provider_class.instances).to be_all { |provider| provider.get(:hasstatus) == true }
     end
 
     it "should discard upstart jobs", :if => Puppet.features.manages_symlinks? do
       not_init_service, *valid_services = @services
       path = "tmp/#{not_init_service}"
-      allow(Puppet::FileSystem).to receive(:symlink?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:symlink?).with(Puppet::FileSystem.pathname(path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:readlink).with(Puppet::FileSystem.pathname(path)).and_return("/lib/init/upstart-job")
-      expect(described_class.instances.map(&:name)).to eq(valid_services)
+      Puppet::FileSystem.expects(:symlink?).at_least_once.returns false
+      Puppet::FileSystem.expects(:symlink?).with(Puppet::FileSystem.pathname(path)).returns(true)
+      Puppet::FileSystem.expects(:readlink).with(Puppet::FileSystem.pathname(path)).returns("/lib/init/upstart-job")
+      expect(provider_class.instances.map(&:name)).to eq(valid_services)
     end
 
     it "should discard non-initscript scripts" do
       valid_services = @services
       all_services = valid_services + excludes
-      expect(Dir).to receive(:entries).with('tmp').and_return(all_services)
-      expect(described_class.instances.map(&:name)).to match_array(valid_services)
+      Dir.expects(:entries).with('tmp').returns all_services
+      expect(provider_class.instances.map(&:name)).to match_array(valid_services)
     end
   end
 
   describe "when checking valid paths" do
     it "should discard paths that do not exist" do
-      expect(File).to receive(:directory?).with(paths[0]).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with(paths[0]).and_return(false)
-      expect(File).to receive(:directory?).with(paths[1]).and_return(true)
+      File.expects(:directory?).with(paths[0]).returns false
+      Puppet::FileSystem.expects(:exist?).with(paths[0]).returns false
+      File.expects(:directory?).with(paths[1]).returns true
 
       expect(provider.paths).to eq([paths[1]])
     end
 
     it "should discard paths that are not directories" do
       paths.each do |path|
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(File).to receive(:directory?).with(path).and_return(false)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        File.expects(:directory?).with(path).returns false
       end
       expect(provider.paths).to be_empty
     end
@@ -115,32 +122,32 @@ describe Puppet::Type.type(:service).provider(:init) do
 
   describe "when searching for the init script" do
     before :each do
-      paths.each {|path| expect(File).to receive(:directory?).with(path).and_return(true) }
+      paths.each {|path| File.expects(:directory?).with(path).returns true }
     end
 
     it "should be able to find the init script in the service path" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(true)
-      expect(Puppet::FileSystem).not_to receive(:exist?).with("#{paths[1]}/myservice") # first one wins
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns true
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").never # first one wins
       expect(provider.initscript).to eq("/service/path/myservice")
     end
 
     it "should be able to find the init script in an alternate service path" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[1]}/myservice").and_return(true)
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns true
       expect(provider.initscript).to eq("/alt/service/path/myservice")
     end
 
     it "should be able to find the init script if it ends with .sh" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[1]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice.sh").and_return(true)
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice.sh").returns true
       expect(provider.initscript).to eq("/service/path/myservice.sh")
     end
 
     it "should fail if the service isn't there" do
       paths.each do |path|
-        expect(Puppet::FileSystem).to receive(:exist?).with("#{path}/myservice").and_return(false)
-        expect(Puppet::FileSystem).to receive(:exist?).with("#{path}/myservice.sh").and_return(false)
+        Puppet::FileSystem.expects(:exist?).with("#{path}/myservice").returns false
+        Puppet::FileSystem.expects(:exist?).with("#{path}/myservice.sh").returns false
       end
       expect { provider.initscript }.to raise_error(Puppet::Error, "Could not find init script for 'myservice'")
     end
@@ -148,24 +155,23 @@ describe Puppet::Type.type(:service).provider(:init) do
 
   describe "if the init script is present" do
     before :each do
-      allow(File).to receive(:directory?).with("/service/path").and_return(true)
-      allow(File).to receive(:directory?).with("/alt/service/path").and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with("/service/path/myservice").and_return(true)
+      File.stubs(:directory?).with("/service/path").returns true
+      File.stubs(:directory?).with("/alt/service/path").returns true
+      Puppet::FileSystem.stubs(:exist?).with("/service/path/myservice").returns true
     end
 
     [:start, :stop, :status, :restart].each do |method|
       it "should have a #{method} method" do
         expect(provider).to respond_to(method)
       end
-
       describe "when running #{method}" do
         before :each do
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
         end
 
         it "should use any provided explicit command" do
           resource[method] = "/user/specified/command"
-          expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
+          provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
 
           provider.send(method)
         end
@@ -173,7 +179,7 @@ describe Puppet::Type.type(:service).provider(:init) do
         it "should pass #{method} to the init script when no explicit command is provided" do
           resource[:hasrestart] = :true
           resource[:hasstatus] = :true
-          expect(provider).to receive(:execute).with(["/service/path/myservice", method], any_args)
+          provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
 
           provider.send(method)
         end
@@ -185,40 +191,35 @@ describe Puppet::Type.type(:service).provider(:init) do
         before :each do
           resource[:hasstatus] = :true
         end
-
         it "should execute the command" do
-          expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           provider.status
         end
-
         it "should consider the process running if the command returns 0" do
-          expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           expect(provider.status).to eq(:running)
         end
-
         [-10,-1,1,10].each { |ec|
           it "should consider the process stopped if the command returns something non-0" do
-            expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+            provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+            $CHILD_STATUS.stubs(:exitstatus).returns(ec)
             expect(provider.status).to eq(:stopped)
           end
         }
       end
-
       describe "when hasstatus is not :true" do
         before :each do
           resource[:hasstatus] = :false
         end
 
         it "should consider the service :running if it has a pid" do
-          expect(provider).to receive(:getpid).and_return("1234")
+          provider.expects(:getpid).returns "1234"
           expect(provider.status).to eq(:running)
         end
-
         it "should consider the service :stopped if it doesn't have a pid" do
-          expect(provider).to receive(:getpid).and_return(nil)
+          provider.expects(:getpid).returns nil
           expect(provider.status).to eq(:stopped)
         end
       end
@@ -230,27 +231,27 @@ describe Puppet::Type.type(:service).provider(:init) do
       end
 
       it "should stop and restart the process" do
-        expect(provider).to receive(:texecute).with(:stop,  ['/service/path/myservice', :stop ], true).and_return("")
-        expect(provider).to receive(:texecute).with(:start, ['/service/path/myservice', :start], true).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        provider.expects(:texecute).with(:stop, ['/service/path/myservice', :stop ], true).returns("")
+        provider.expects(:texecute).with(:start,['/service/path/myservice', :start], true).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         provider.restart
       end
     end
 
     describe "when starting a service on Solaris" do
       it "should use ctrun" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-        expect(provider).to receive(:execute).with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        provider.expects(:execute).with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         provider.start
       end
     end
 
     describe "when starting a service on RedHat" do
       it "should not use ctrun" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-        expect(provider).to receive(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        Facter.stubs(:value).with(:osfamily).returns 'RedHat'
+        provider.expects(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         provider.start
       end
     end